@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/rawStreamCapture.ts

@@ -1,342 +0,0 @@
-import assert from "node:assert/strict";
-import { Buffer } from "node:buffer";
-import { randomUUID } from "node:crypto";
-import { open, unlink, type FileHandle } from "node:fs/promises";
-import { join } from "node:path";
-import { getDataDir } from "./dataDir";
-import {
-  DEFAULT_RUNTIME_BUDGET_POLICY,
-  type RuntimeBudgetPolicy,
-  runtimeBudgetPolicySnapshot,
-} from "~/lib/resourceLimits";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-
-const DEFAULT_MEMORY_LIMIT_BYTES = 1024 * 1024;
-const FILE_WRITE_BATCH_BYTES = 64 * 1024;
-const DEFAULT_QUEUE_MAX_MESSAGES = 256;
-const DEFAULT_QUEUE_MAX_BYTES = 8 * 1024 * 1024;
-const DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES = 4096;
-const DEFAULT_GLOBAL_QUEUE_MAX_BYTES = 64 * 1024 * 1024;
-const activeCaptures = new Set<RawStreamCapture>();
-
-export type RawStreamCaptureGapReason = "capacity-exceeded" | "pipeline-closed" | "write-failed";
-
-export type RawStreamCaptureStatus = {
-  incomplete: boolean;
-  droppedChunks: number;
-  droppedBytes: number;
-  reason: RawStreamCaptureGapReason | null;
-};
-
-export type RawStreamCaptureOptions = {
-  memoryLimitBytes?: number;
-  queueMaxMessages?: number;
-  queueMaxBytes?: number;
-  globalBudget?: RawStreamObservationBudget;
-};
-
-export function rawStreamCaptureOptionsFromBudgetPolicy(
-  policy: RuntimeBudgetPolicy = DEFAULT_RUNTIME_BUDGET_POLICY,
-): Pick<RawStreamCaptureOptions, "queueMaxMessages" | "queueMaxBytes"> {
-  const snapshot = runtimeBudgetPolicySnapshot(policy);
-  return {
-    queueMaxMessages: snapshot.queues.rawStreamMessages,
-    queueMaxBytes: snapshot.queues.rawStreamBytes,
-  };
-}
-
-export type RawStreamSource =
-  | {
-      type: "memory";
-      rawStream: string;
-    }
-  | {
-      type: "file";
-      path: string;
-    };
-
-function resolveMemoryLimitBytes(): number {
-  const raw = process.env["AGENT_INSPECTOR_STREAM_MEMORY_LIMIT_BYTES"];
-  if (raw === undefined || raw === "") return DEFAULT_MEMORY_LIMIT_BYTES;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < 0) return DEFAULT_MEMORY_LIMIT_BYTES;
-  return parsed;
-}
-
-function resolvePositiveIntegerEnv(name: string, fallback: number): number {
-  const raw = process.env[name];
-  if (raw === undefined || raw === "") return fallback;
-  const parsed = Number(raw);
-  if (!Number.isSafeInteger(parsed) || parsed < 1) return fallback;
-  return parsed;
-}
-
-function defaultQueueMaxMessages(): number {
-  return resolvePositiveIntegerEnv(
-    "AGENT_INSPECTOR_OBSERVATION_QUEUE_MESSAGES",
-    DEFAULT_QUEUE_MAX_MESSAGES,
-  );
-}
-
-function defaultQueueMaxBytes(): number {
-  return resolvePositiveIntegerEnv(
-    "AGENT_INSPECTOR_OBSERVATION_QUEUE_BYTES",
-    DEFAULT_QUEUE_MAX_BYTES,
-  );
-}
-
-export class RawStreamObservationBudget {
-  private messages = 0;
-  private bytes = 0;
-
-  constructor(
-    private readonly maxMessages: number,
-    private readonly maxBytes: number,
-  ) {}
-
-  tryAcquire(bytes: number): (() => void) | null {
-    if (this.messages + 1 > this.maxMessages || this.bytes + bytes > this.maxBytes) return null;
-    this.messages += 1;
-    this.bytes += bytes;
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.messages -= 1;
-      this.bytes -= bytes;
-    };
-  }
-}
-
-const globalObservationBudget = new RawStreamObservationBudget(
-  resolvePositiveIntegerEnv(
-    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_MESSAGES",
-    DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES,
-  ),
-  resolvePositiveIntegerEnv(
-    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_BYTES",
-    DEFAULT_GLOBAL_QUEUE_MAX_BYTES,
-  ),
-);
-
-export function getRawStreamDir(): string {
-  return join(getDataDir(), "raw-streams");
-}
-
-function createRawStreamPath(): string {
-  return join(getRawStreamDir(), `${Date.now()}-${randomUUID()}.stream.tmp`);
-}
-
-export class RawStreamCapture {
-  private readonly memoryLimitBytes: number;
-  private readonly queueMaxMessages: number;
-  private readonly queueMaxBytes: number;
-  private readonly globalBudget: RawStreamObservationBudget;
-  private chunks: string[] = [];
-  private byteLength = 0;
-  private filePath: string | null = null;
-  private fileHandle: FileHandle | null = null;
-  private pendingFileChunks: string[] = [];
-  private pendingFileBytes = 0;
-  private operation = Promise.resolve();
-  private accepting = true;
-  private closed = false;
-  private sawChunk = false;
-  private queuedMessages = 0;
-  private queuedBytes = 0;
-  private incomplete = false;
-  private storageFailed = false;
-  private droppedChunks = 0;
-  private droppedBytes = 0;
-  private gapReason: RawStreamCaptureGapReason | null = null;
-
-  constructor(options: RawStreamCaptureOptions = {}) {
-    this.memoryLimitBytes = options.memoryLimitBytes ?? resolveMemoryLimitBytes();
-    this.queueMaxMessages = options.queueMaxMessages ?? defaultQueueMaxMessages();
-    this.queueMaxBytes = options.queueMaxBytes ?? defaultQueueMaxBytes();
-    this.globalBudget = options.globalBudget ?? globalObservationBudget;
-    activeCaptures.add(this);
-  }
-
-  get hasChunks(): boolean {
-    return this.sawChunk;
-  }
-
-  get status(): RawStreamCaptureStatus {
-    return {
-      incomplete: this.incomplete,
-      droppedChunks: this.droppedChunks,
-      droppedBytes: this.droppedBytes,
-      reason: this.gapReason,
-    };
-  }
-
-  recordDroppedObservation(reason: RawStreamCaptureGapReason, observedBytes: number): void {
-    const safeObservedBytes =
-      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
-    this.recordGap(reason, safeObservedBytes, safeObservedBytes > 0);
-  }
-
-  async append(text: string): Promise<void> {
-    if (text === "") return;
-    const next = this.operation.then(() => this.appendInternal(text));
-    this.operation = next.catch(() => undefined);
-    return next;
-  }
-
-  /**
-   * Submit an observation without waiting for file I/O. Once capacity is exceeded, capture remains
-   * incomplete and all later chunks are counted as dropped so the persisted value is an honest
-   * prefix rather than a misleading stream with an unmarked hole.
-   */
-  tryAppend(text: string, observedBytes: number): boolean {
-    const safeObservedBytes =
-      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
-    const queuedBytes = Math.max(safeObservedBytes, Buffer.byteLength(text, "utf-8"));
-
-    if (!this.accepting || this.closed) {
-      this.recordGap("pipeline-closed", safeObservedBytes, safeObservedBytes > 0 || text !== "");
-      return false;
-    }
-    if (this.incomplete) {
-      this.recordGap("capacity-exceeded", safeObservedBytes, safeObservedBytes > 0 || text !== "");
-      return false;
-    }
-    if (text === "") return true;
-    if (
-      this.queuedMessages + 1 > this.queueMaxMessages ||
-      this.queuedBytes + queuedBytes > this.queueMaxBytes
-    ) {
-      this.recordGap("capacity-exceeded", safeObservedBytes, true);
-      return false;
-    }
-
-    const releaseGlobal = this.globalBudget.tryAcquire(queuedBytes);
-    if (releaseGlobal === null) {
-      this.recordGap("capacity-exceeded", safeObservedBytes, true);
-      return false;
-    }
-
-    this.queuedMessages += 1;
-    this.queuedBytes += queuedBytes;
-    this.operation = this.operation
-      .then(async () => {
-        if (this.storageFailed) {
-          this.recordGap("write-failed", safeObservedBytes, true);
-          return;
-        }
-        await this.appendInternal(text);
-      })
-      .catch(() => {
-        this.storageFailed = true;
-        this.recordGap("write-failed", safeObservedBytes, true);
-      })
-      .finally(() => {
-        this.queuedMessages -= 1;
-        this.queuedBytes -= queuedBytes;
-        releaseGlobal();
-      });
-    return true;
-  }
-
-  async finalize(): Promise<RawStreamSource> {
-    this.accepting = false;
-    const next = this.operation.then(() => this.finalizeInternal());
-    this.operation = next.then(
-      () => undefined,
-      () => undefined,
-    );
-    return next.finally(() => activeCaptures.delete(this));
-  }
-
-  private async appendInternal(text: string): Promise<void> {
-    if (this.closed) return;
-    this.sawChunk = true;
-
-    const nextBytes = Buffer.byteLength(text, "utf-8");
-    if (this.filePath === null && this.byteLength + nextBytes <= this.memoryLimitBytes) {
-      this.chunks.push(text);
-      this.byteLength += nextBytes;
-      return;
-    }
-
-    if (this.filePath === null) {
-      await this.spillToFile();
-    }
-
-    if (this.filePath !== null) {
-      this.pendingFileChunks.push(text);
-      this.pendingFileBytes += nextBytes;
-      this.byteLength += nextBytes;
-      if (this.pendingFileBytes >= FILE_WRITE_BATCH_BYTES) await this.flushFileBuffer();
-    }
-  }
-
-  private recordGap(
-    reason: RawStreamCaptureGapReason,
-    observedBytes: number,
-    countChunk: boolean,
-  ): void {
-    this.incomplete = true;
-    this.gapReason ??= reason;
-    if (countChunk) this.droppedChunks += 1;
-    this.droppedBytes += observedBytes;
-  }
-
-  private async finalizeInternal(): Promise<RawStreamSource> {
-    if (!this.closed) {
-      this.closed = true;
-      await this.flushFileBuffer();
-      if (this.fileHandle !== null) {
-        const handle = this.fileHandle;
-        this.fileHandle = null;
-        try {
-          await handle.sync();
-        } finally {
-          await handle.close();
-        }
-      }
-    }
-    if (this.filePath !== null) {
-      return { type: "file", path: this.filePath };
-    }
-    return { type: "memory", rawStream: this.chunks.join("") };
-  }
-
-  private async spillToFile(): Promise<void> {
-    const path = createRawStreamPath();
-    assert(ensurePrivateDirectorySync(getRawStreamDir()), "Could not secure raw-stream directory");
-    const handle = await open(path, "wx", PRIVATE_FILE_MODE);
-    let committed = false;
-    try {
-      const memoryText = this.chunks.join("");
-      if (memoryText.length > 0) await handle.write(memoryText, undefined, "utf-8");
-      assert(securePrivateFileSync(path), "Could not secure raw-stream file");
-      this.filePath = path;
-      this.fileHandle = handle;
-      this.chunks = [];
-      committed = true;
-    } finally {
-      if (!committed) {
-        await handle.close().catch(() => undefined);
-        await unlink(path).catch(() => undefined);
-      }
-    }
-  }
-
-  private async flushFileBuffer(): Promise<void> {
-    if (this.fileHandle === null || this.pendingFileChunks.length === 0) return;
-    const text = this.pendingFileChunks.join("");
-    this.pendingFileChunks = [];
-    this.pendingFileBytes = 0;
-    await this.fileHandle.write(text, undefined, "utf-8");
-  }
-}
-
-export async function flushAllRawStreamCaptures(): Promise<void> {
-  await Promise.all([...activeCaptures].map((capture) => capture.finalize()));
-}

package/src/proxy/runFailures.ts

@@ -1,94 +0,0 @@
-import {
-  EvidenceExportResultSchema,
-  type EvidenceExportResult,
-  type FailureClassification,
-  type InspectorRun,
-  type InspectorRunEvidence,
-  type JenkinsReport,
-  type RecentFailure,
-  type RecentFailuresResponse,
-} from "../lib/runContract";
-import { readJsonFile } from "../lib/jsonFile";
-import { listRuns } from "./runStore";
-
-export const RECENT_FAILURES_DEFAULT_LIMIT = 5;
-export const RECENT_FAILURES_MAX_LIMIT = 20;
-
-export function clampRecentFailuresLimit(value: number): number {
-  if (!Number.isInteger(value) || value < 1) return RECENT_FAILURES_DEFAULT_LIMIT;
-  return Math.min(value, RECENT_FAILURES_MAX_LIMIT);
-}
-
-function readEvidenceDocument(run: InspectorRun): EvidenceExportResult | null {
-  const path = run.evidence?.jsonPath;
-  if (path === undefined) return null;
-  const result = readJsonFile(path, EvidenceExportResultSchema);
-  return result.ok ? result.data : null;
-}
-
-function syntheticFailedClassification(run: InspectorRun): FailureClassification {
-  return {
-    outcome: "failure",
-    severity: "high",
-    category: "unknown-failure",
-    summary: `Run ${run.id} is marked ${run.status}, but no exported evidence document was available.`,
-    evidenceLogIds: [],
-    hints: [
-      "Call inspector_export_evidence for this run to collect session metrics, failing log ids, and artifact paths.",
-      "Confirm the run's sessionId matches the coding agent traffic captured by Inspector.",
-    ],
-  };
-}
-
-function shouldIncludeRun(
-  run: InspectorRun,
-  document: EvidenceExportResult | null,
-  classification: FailureClassification,
-): boolean {
-  if (run.status === "failed" || run.status === "cancelled") return true;
-  if (document === null) return false;
-  return classification.outcome !== "success";
-}
-
-function evidenceFor(
-  run: InspectorRun,
-  document: EvidenceExportResult | null,
-): InspectorRunEvidence | null {
-  return document?.evidence ?? run.evidence;
-}
-
-function jenkinsReportFor(document: EvidenceExportResult | null): JenkinsReport | null {
-  return document?.jenkinsReport ?? null;
-}
-
-function failureFromRun(run: InspectorRun): RecentFailure | null {
-  const document = readEvidenceDocument(run);
-  const classification =
-    document === null ? syntheticFailedClassification(run) : document.classification;
-  if (!shouldIncludeRun(run, document, classification)) return null;
-
-  const evidence = evidenceFor(run, document);
-  return {
-    run,
-    classification,
-    evidence,
-    jenkinsReport: jenkinsReportFor(document),
-    sessionId: run.sessionId,
-    inspectorUrl: document?.session?.inspectorUrl ?? null,
-    evidenceMarkdownPath: evidence?.markdownPath ?? null,
-    updatedAt: evidence?.exportedAt ?? run.updatedAt,
-  };
-}
-
-export function listRecentFailures(limit: number): RecentFailuresResponse {
-  const failures = listRuns()
-    .map(failureFromRun)
-    .filter((failure): failure is RecentFailure => failure !== null)
-    .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-  const clampedLimit = clampRecentFailuresLimit(limit);
-  return {
-    failures: failures.slice(0, clampedLimit),
-    total: failures.length,
-    limit: clampedLimit,
-  };
-}

package/src/proxy/runStore.ts

@@ -1,214 +0,0 @@
-import assert from "node:assert/strict";
-import { writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
-import { z } from "zod";
-import {
-  CreateInspectorRunInputSchema,
-  InspectorRunSchema,
-  UpdateInspectorRunInputSchema,
-  type CreateInspectorRunInput,
-  type InspectorRun,
-  type InspectorRunEvidence,
-  type UpdateInspectorRunInput,
-} from "../lib/runContract";
-import { getDataDir } from "./dataDir";
-import { addGroupSession, getGroup } from "./groupStore";
-import { readJsonFile } from "../lib/jsonFile";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-
-const RunsFileSchema = z.object({
-  runs: z.array(InspectorRunSchema),
-});
-
-function runsFilePath(): string {
-  return join(getDataDir(), "runs.json");
-}
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function stableId(input: string): string {
-  return input
-    .trim()
-    .replace(/[^A-Za-z0-9_.-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
-}
-
-function createRunId(): string {
-  return `run_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-}
-
-function normalizeRunId(input: string | undefined): string {
-  if (input === undefined) return createRunId();
-  const normalized = stableId(input);
-  return normalized.length > 0 ? normalized : createRunId();
-}
-
-function normalizeSessionId(input: string | undefined, runId: string): string {
-  if (input === undefined || input.trim().length === 0) return runId;
-  return input.trim();
-}
-
-function normalizeGroupId(input: string | null | undefined): string | null {
-  if (input === undefined || input === null) return null;
-  const normalized = stableId(input);
-  return normalized.length > 0 ? normalized : null;
-}
-
-function metadataText(metadata: InspectorRun["metadata"], key: string): string | undefined {
-  const value = metadata[key];
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function optionalText(value: string | null): string | undefined {
-  return value ?? undefined;
-}
-
-function autoGroupMemberId(runId: string): string {
-  return stableId(`run-${runId}`);
-}
-
-function runHasGroupMember(run: InspectorRun): boolean {
-  if (run.groupId === null) return false;
-  const group = getGroup(run.groupId);
-  if (group === null) return false;
-  return group.members.some((member) => member.id === autoGroupMemberId(run.id));
-}
-
-function syncRunGroupMember(run: InspectorRun, createIfMissing: boolean): void {
-  if (run.groupId === null) return;
-  if (!createIfMissing && !runHasGroupMember(run)) return;
-
-  addGroupSession(run.groupId, {
-    memberId: autoGroupMemberId(run.id),
-    sessionId: run.sessionId,
-    runId: run.id,
-    label: run.title,
-    agent: optionalText(run.agent),
-    provider: metadataText(run.metadata, "provider") ?? metadataText(run.metadata, "providerName"),
-    model: metadataText(run.metadata, "model") ?? metadataText(run.metadata, "modelName"),
-    status: run.status,
-    metadata: run.metadata,
-  });
-}
-
-function readRuns(): InspectorRun[] {
-  const result = readJsonFile(runsFilePath(), RunsFileSchema);
-  return result.ok ? result.data.runs : [];
-}
-
-function writeRuns(runs: readonly InspectorRun[]): void {
-  const filePath = runsFilePath();
-  assert(ensurePrivateDirectorySync(dirname(filePath)), "Could not secure runs directory");
-  writeFileSync(filePath, `${JSON.stringify({ runs }, null, 2)}\n`, {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  assert(securePrivateFileSync(filePath), "Could not secure runs file");
-}
-
-export function listRuns(): InspectorRun[] {
-  return readRuns().sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-}
-
-export function getRun(runId: string): InspectorRun | null {
-  return readRuns().find((run) => run.id === runId) ?? null;
-}
-
-export function createRun(input: CreateInspectorRunInput): InspectorRun {
-  const parsed = CreateInspectorRunInputSchema.parse(input);
-  const runId = normalizeRunId(parsed?.runId);
-  const existing = getRun(runId);
-  if (existing !== null) return existing;
-
-  const timestamp = nowIso();
-  const sessionId = normalizeSessionId(parsed?.sessionId, runId);
-  const groupId = normalizeGroupId(parsed?.groupId);
-  const run: InspectorRun = {
-    id: runId,
-    sessionId,
-    groupId,
-    title: parsed?.title ?? `Inspector Run ${runId}`,
-    task: parsed?.task ?? null,
-    project: parsed?.project ?? null,
-    agent: parsed?.agent ?? null,
-    status: parsed?.status ?? "created",
-    tags: parsed?.tags ?? [],
-    metadata: parsed?.metadata ?? {},
-    evidence: null,
-    createdAt: timestamp,
-    updatedAt: timestamp,
-  };
-
-  writeRuns([...readRuns(), run]);
-  syncRunGroupMember(run, parsed?.sessionId !== undefined);
-  return run;
-}
-
-export function updateRunEvidence(
-  runId: string,
-  evidence: InspectorRunEvidence,
-): InspectorRun | null {
-  const runs = readRuns();
-  let updatedRun: InspectorRun | null = null;
-  const updatedRuns = runs.map((run) => {
-    if (run.id !== runId) return run;
-    updatedRun = {
-      ...run,
-      evidence,
-      updatedAt: evidence.exportedAt,
-    };
-    return updatedRun;
-  });
-  if (updatedRun === null) return null;
-  writeRuns(updatedRuns);
-  return updatedRun;
-}
-
-export function updateRun(runId: string, input: UpdateInspectorRunInput): InspectorRun | null {
-  const parsed = UpdateInspectorRunInputSchema.parse(input);
-  const runs = readRuns();
-  const run = runs.find((candidate) => candidate.id === runId) ?? null;
-  const updatedAt = nowIso();
-
-  if (run === null) return null;
-
-  const updatedRun: InspectorRun = {
-    ...run,
-    sessionId:
-      parsed.sessionId === undefined ? run.sessionId : normalizeSessionId(parsed.sessionId, run.id),
-    groupId: parsed.groupId === undefined ? run.groupId : normalizeGroupId(parsed.groupId),
-    title: parsed.title ?? run.title,
-    task: parsed.task === undefined ? run.task : parsed.task,
-    project: parsed.project === undefined ? run.project : parsed.project,
-    agent: parsed.agent === undefined ? run.agent : parsed.agent,
-    status: parsed.status ?? run.status,
-    tags: parsed.tags ?? run.tags,
-    metadata:
-      parsed.metadata === undefined ? run.metadata : { ...run.metadata, ...parsed.metadata },
-    updatedAt,
-  };
-  const updatedRuns = runs.map((candidate) => (candidate.id === runId ? updatedRun : candidate));
-
-  writeRuns(updatedRuns);
-  syncRunGroupMember(
-    updatedRun,
-    parsed.sessionId !== undefined ||
-      parsed.groupId !== undefined ||
-      updatedRun.sessionId !== updatedRun.id,
-  );
-  return updatedRun;
-}
-
-export function _resetRunsForTests(): void {
-  writeRuns([]);
-}

package/src/proxy/runtimeAdmission.ts

@@ -1,55 +0,0 @@
-import { MAX_ACTIVE_PROXY_REQUESTS } from "../lib/resourceLimits";
-
-export type RuntimeRequestLease = {
-  release: () => void;
-};
-
-let acceptingRequests = true;
-let activeRequests = 0;
-const drainWaiters = new Set<() => void>();
-
-function notifyDrained(): void {
-  if (activeRequests !== 0) return;
-  for (const resolve of drainWaiters) resolve();
-  drainWaiters.clear();
-}
-
-export function acquireRuntimeRequest(): RuntimeRequestLease | null {
-  if (!acceptingRequests || activeRequests >= MAX_ACTIVE_PROXY_REQUESTS) return null;
-  activeRequests += 1;
-  let released = false;
-  return {
-    release(): void {
-      if (released) return;
-      released = true;
-      activeRequests = Math.max(0, activeRequests - 1);
-      notifyDrained();
-    },
-  };
-}
-
-export function stopRuntimeAdmission(): void {
-  acceptingRequests = false;
-  notifyDrained();
-}
-
-export async function waitForRuntimeTrafficDrain(): Promise<void> {
-  if (activeRequests === 0) return;
-  await new Promise<void>((resolve) => {
-    drainWaiters.add(resolve);
-  });
-}
-
-export function getRuntimeAdmissionState(): {
-  acceptingRequests: boolean;
-  activeRequests: number;
-  capacity: number;
-} {
-  return { acceptingRequests, activeRequests, capacity: MAX_ACTIVE_PROXY_REQUESTS };
-}
-
-export function _resetRuntimeAdmissionForTests(): void {
-  acceptingRequests = true;
-  activeRequests = 0;
-  notifyDrained();
-}