@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/formats/providerRegistry.ts

@@ -1,51 +0,0 @@
-import type { ProviderAdapter } from "./providerAdapter";
-
-/**
- * Provider Registry
- *
- * Singleton registry for provider implementations.
- * Providers register themselves at module load time.
- */
-class ProviderRegistryImpl {
-  private providers: ProviderAdapter[] = [];
-
-  /**
-   * Register a provider with the registry.
-   * @param provider - Provider implementation to register
-   */
-  register(provider: ProviderAdapter): void {
-    this.providers.push(provider);
-  }
-
-  /**
-   * Find the first provider that matches the given model.
-   * @param model - Model name to match
-   * @returns Matching provider or null if none found
-   */
-  findProvider(model: string): ProviderAdapter | null {
-    let fallback: ProviderAdapter | null = null;
-
-    for (const provider of this.providers) {
-      if (provider.matches(model)) {
-        // Non-anthropic providers win immediately (explicit match)
-        if (provider.name !== "anthropic") {
-          return provider;
-        }
-        // Anthropic is the fallback; only use if nothing else matches
-        fallback = provider;
-      }
-    }
-    return fallback;
-  }
-
-  /**
-   * Get all registered providers.
-   * @returns Array of all registered providers
-   */
-  getAll(): ProviderAdapter[] {
-    return [...this.providers];
-  }
-}
-
-/** Global registry instance */
-export const registry = new ProviderRegistryImpl();

package/src/proxy/formats/providers/index.ts

@@ -1,3 +0,0 @@
-// Provider types and registry
-export type { ProviderAdapter } from "../providerAdapter";
-export { registry } from "../providerRegistry";

package/src/proxy/formats/registry.ts

@@ -1,65 +0,0 @@
-import type { FormatHandler } from "./handler";
-import type { ApiFormat } from "../schemas";
-import { API_FORMAT_PATH_ENTRIES, apiFormatForPath } from "../../lib/apiFormat";
-
-export { apiFormatForPath };
-
-/**
- * API format registry maps request paths and API formats to their FormatHandler.
- *
- * Registered at module load time by each format's init module.
- */
-class FormatRegistryImpl {
-  private handlers = new Map<ApiFormat, FormatHandler>();
-  private pathMap = new Map<string, ApiFormat>();
-
-  register(handler: FormatHandler): void {
-    this.handlers.set(handler.format, handler);
-  }
-
-  registerPath(path: string, format: ApiFormat): void {
-    this.pathMap.set(path, format);
-  }
-
-  /** Get handler by format identifier */
-  get(format: ApiFormat): FormatHandler | undefined {
-    return this.handlers.get(format);
-  }
-
-  /** Get handler matching a request path */
-  getByPath(path: string): FormatHandler | undefined {
-    const messagesPath = path.split("?")[0] ?? "";
-    const format = this.pathMap.get(messagesPath);
-    return format === undefined ? undefined : this.handlers.get(format);
-  }
-
-  /** Get the API format matching a request path without requiring handlers. */
-  getApiFormatByPath(path: string): ApiFormat | undefined {
-    const messagesPath = path.split("?")[0] ?? "";
-    return this.pathMap.get(messagesPath);
-  }
-
-  /** Detect API format from request body content */
-  detectFormat(rawBody: string | null): ApiFormat {
-    if (rawBody === null) return "unknown";
-    for (const handler of this.handlers.values()) {
-      if (handler.detectFormat(rawBody)) return handler.format;
-    }
-    return "unknown";
-  }
-}
-
-export const formatRegistry = new FormatRegistryImpl();
-
-/**
- * Get the FormatHandler for a request path.
- * Returns null if no format matches the path.
- */
-export function formatForPath(path: string): FormatHandler | null {
-  return formatRegistry.getByPath(path) ?? null;
-}
-
-// Register known paths
-for (const [path, format] of API_FORMAT_PATH_ENTRIES) {
-  formatRegistry.registerPath(path, format);
-}

package/src/proxy/groupEvidenceExporter.ts

@@ -1,371 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import {
-  GroupEvidenceExportResultSchema,
-  type GroupEvidenceExportOptions,
-  type GroupEvidenceExportResult,
-  type InspectorGroup,
-  type InspectorGroupEvidence,
-  type InspectorGroupEvidenceSummary,
-  type InspectorGroupExportMember,
-} from "../lib/groupContract";
-import type { JenkinsReport } from "../lib/runContract";
-import type { SessionInfo, SessionTokenUsage } from "../lib/sessionInfoContract";
-import { getDataDir } from "./dataDir";
-import { getRun } from "./runStore";
-import { getSessionInfo } from "./store";
-import { updateGroupEvidence } from "./groupStore";
-import { readJsonFile } from "../lib/jsonFile";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-
-type GroupEvidenceDocument = GroupEvidenceExportResult;
-
-function groupEvidenceDir(groupId: string): string {
-  return join(getDataDir(), "evidence", "groups", groupId);
-}
-
-function jsonPath(groupId: string): string {
-  return join(groupEvidenceDir(groupId), "evidence.json");
-}
-
-function markdownPath(groupId: string): string {
-  return join(groupEvidenceDir(groupId), "evidence.md");
-}
-
-function htmlPath(groupId: string): string {
-  return join(groupEvidenceDir(groupId), "evidence.html");
-}
-
-function escapeMarkdownCell(value: string): string {
-  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
-}
-
-function escapeHtml(value: string): string {
-  return value
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}
-
-function formatText(value: string | null | undefined): string {
-  if (value === null || value === undefined || value.length === 0) return "n/a";
-  return value;
-}
-
-function formatNumber(value: number | null | undefined): string {
-  if (value === null || value === undefined) return "n/a";
-  return String(value);
-}
-
-function collectSortedValues(values: readonly (string | null | undefined)[]): string[] {
-  const set = new Set<string>();
-  for (const value of values) {
-    if (value !== null && value !== undefined && value.length > 0) {
-      set.add(value);
-    }
-  }
-  return [...set].sort();
-}
-
-function addTokenUsage(total: SessionTokenUsage, session: SessionInfo | null): SessionTokenUsage {
-  if (session === null) return total;
-  return {
-    input: total.input + session.tokenUsage.input,
-    output: total.output + session.tokenUsage.output,
-    cacheCreate: total.cacheCreate + session.tokenUsage.cacheCreate,
-    cacheRead: total.cacheRead + session.tokenUsage.cacheRead,
-    total: total.total + session.tokenUsage.total,
-  };
-}
-
-function memberEffectiveStatus(member: InspectorGroupExportMember): string {
-  if (member.member.status !== null) return member.member.status;
-  if (member.run !== null) return member.run.status;
-  return member.session?.status ?? "unknown";
-}
-
-function isCompletedMember(member: InspectorGroupExportMember): boolean {
-  const status = memberEffectiveStatus(member);
-  return status === "completed";
-}
-
-function isFailedMember(member: InspectorGroupExportMember): boolean {
-  const status = memberEffectiveStatus(member);
-  return status === "failed" || status === "cancelled";
-}
-
-function isRunningMember(member: InspectorGroupExportMember): boolean {
-  const status = memberEffectiveStatus(member);
-  return status === "running" || status === "active";
-}
-
-function latestLogMetric(
-  session: SessionInfo | null,
-  field: "firstChunkMs" | "totalStreamMs" | "tokensPerSecond",
-): number | null {
-  if (session === null) return null;
-  for (const log of session.latestLogs) {
-    const value = log[field];
-    if (value !== undefined && value !== null) return value;
-  }
-  return null;
-}
-
-function buildSummary(
-  members: readonly InspectorGroupExportMember[],
-): InspectorGroupEvidenceSummary {
-  const tokenUsage = members.reduce<SessionTokenUsage>(
-    (total, member) => addTokenUsage(total, member.session),
-    { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, total: 0 },
-  );
-  const sessionsWithData = members.filter((member) => member.session !== null).length;
-  const requestCount = members.reduce(
-    (total, member) => total + (member.session?.requestCount ?? 0),
-    0,
-  );
-  const errorCount = members.reduce(
-    (total, member) => total + (member.session?.errorCount ?? 0),
-    0,
-  );
-
-  return {
-    memberCount: members.length,
-    sessionsWithData,
-    missingSessions: members.length - sessionsWithData,
-    requestCount,
-    errorCount,
-    tokenUsage,
-    models: collectSortedValues(
-      members.flatMap((member) => [member.member.model, ...(member.session?.models ?? [])]),
-    ),
-    providers: collectSortedValues(
-      members.flatMap((member) => [member.member.provider, ...(member.session?.providers ?? [])]),
-    ),
-    completedMembers: members.filter(isCompletedMember).length,
-    failedMembers: members.filter(isFailedMember).length,
-    runningMembers: members.filter(isRunningMember).length,
-  };
-}
-
-function buildJenkinsReport(
-  group: InspectorGroup,
-  summary: InspectorGroupEvidenceSummary,
-): JenkinsReport {
-  if (summary.failedMembers > 0 || summary.errorCount > 0 || group.status === "failed") {
-    return {
-      status: "FAIL",
-      summary: `[FAIL] ${summary.failedMembers} failed members, ${summary.errorCount} captured errors.`,
-      markdown: `# Jenkins Report: ${group.title}\n\nStatus: FAIL\n\n${summary.failedMembers} failed members and ${summary.errorCount} captured errors need triage.`,
-    };
-  }
-
-  if (summary.runningMembers > 0 || group.status === "running") {
-    return {
-      status: "RUNNING",
-      summary: `[RUNNING] ${summary.runningMembers} group members are still active.`,
-      markdown: `# Jenkins Report: ${group.title}\n\nStatus: RUNNING\n\n${summary.runningMembers} group members are still active.`,
-    };
-  }
-
-  if (
-    summary.memberCount > 0 &&
-    summary.sessionsWithData > 0 &&
-    summary.errorCount === 0 &&
-    group.status === "completed"
-  ) {
-    return {
-      status: "PASS",
-      summary: `[PASS] ${summary.memberCount} group members completed with no captured errors.`,
-      markdown: `# Jenkins Report: ${group.title}\n\nStatus: PASS\n\n${summary.memberCount} group members completed with no captured errors.`,
-    };
-  }
-
-  return {
-    status: "UNKNOWN",
-    summary: `[UNKNOWN] Group has ${summary.memberCount} members and ${summary.missingSessions} missing sessions.`,
-    markdown: `# Jenkins Report: ${group.title}\n\nStatus: UNKNOWN\n\nExported group evidence, but the outcome is not conclusive yet.`,
-  };
-}
-
-function buildMemberRows(members: readonly InspectorGroupExportMember[]): string[] {
-  if (members.length === 0) return ["No sessions have been attached to this group.", ""];
-
-  const rows = [
-    "| Label | Provider | Model | Session | Run | Status | Requests | Errors | Tokens | First Chunk | Stream Total | TPS | Inspector |",
-    "| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |",
-  ];
-
-  for (const member of members) {
-    const session = member.session;
-    rows.push(
-      [
-        formatText(member.member.label),
-        formatText(member.member.provider ?? session?.providers[0]),
-        formatText(member.member.model ?? session?.lastModel),
-        member.member.sessionId,
-        formatText(member.member.runId),
-        memberEffectiveStatus(member),
-        formatNumber(session?.requestCount),
-        formatNumber(session?.errorCount),
-        formatNumber(session?.tokenUsage.total),
-        formatNumber(latestLogMetric(session, "firstChunkMs")),
-        formatNumber(latestLogMetric(session, "totalStreamMs")),
-        formatNumber(latestLogMetric(session, "tokensPerSecond")),
-        formatText(session?.inspectorUrl),
-      ]
-        .map(escapeMarkdownCell)
-        .join(" | ")
-        .replace(/^/, "| ")
-        .replace(/$/, " |"),
-    );
-  }
-
-  rows.push("");
-  return rows;
-}
-
-function buildMarkdown(document: GroupEvidenceDocument): string {
-  const group = document.group;
-  const summary = document.summary;
-  const lines = [
-    `# ${group.title}`,
-    "",
-    `- Group ID: ${group.id}`,
-    `- Kind: ${group.kind}`,
-    `- Status: ${group.status}`,
-    `- Project: ${group.project ?? "n/a"}`,
-    `- Created: ${group.createdAt}`,
-    `- Members: ${summary.memberCount}`,
-    `- Sessions With Data: ${summary.sessionsWithData}`,
-    `- Missing Sessions: ${summary.missingSessions}`,
-    `- Requests: ${summary.requestCount}`,
-    `- Errors: ${summary.errorCount}`,
-    `- Tokens: ${summary.tokenUsage.total}`,
-    `- Models: ${summary.models.length > 0 ? summary.models.join(", ") : "n/a"}`,
-    `- Providers: ${summary.providers.length > 0 ? summary.providers.join(", ") : "n/a"}`,
-    `- Evidence JSON: ${document.evidence.jsonPath}`,
-    `- Evidence HTML: ${document.evidence.htmlPath}`,
-    "",
-  ];
-
-  if (group.task !== null) {
-    lines.push("## Task", "", group.task, "");
-  }
-
-  lines.push("## Evaluation Matrix", "", ...buildMemberRows(document.members));
-  lines.push("## Jenkins Report", "", document.jenkinsReport.markdown, "");
-
-  return `${lines.join("\n")}\n`;
-}
-
-function buildHtml(markdown: string, title: string): string {
-  return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>${escapeHtml(title)}</title>
-  <style>
-    body { font-family: system-ui, sans-serif; max-width: 1120px; margin: 40px auto; line-height: 1.5; }
-    pre { white-space: pre-wrap; background: #f6f8fa; padding: 16px; border-radius: 8px; }
-  </style>
-</head>
-<body>
-  <pre>${escapeHtml(markdown)}</pre>
-</body>
-</html>
-`;
-}
-
-async function buildExportMembers(
-  group: InspectorGroup,
-  options: GroupEvidenceExportOptions,
-  baseUrl: string,
-): Promise<InspectorGroupExportMember[]> {
-  const members: InspectorGroupExportMember[] = [];
-  for (const member of group.members) {
-    const run = member.runId === null ? null : getRun(member.runId);
-    const session = await getSessionInfo(member.sessionId, {
-      baseUrl,
-      includeHistory: options?.includeHistory,
-      latestLogLimit: options?.latestLogLimit,
-    });
-    members.push({ member, run, session });
-  }
-  return members;
-}
-
-export async function exportGroupEvidence(
-  group: InspectorGroup,
-  options: GroupEvidenceExportOptions,
-  baseUrl: string,
-): Promise<GroupEvidenceExportResult> {
-  const members = await buildExportMembers(group, options, baseUrl);
-  const exportedAt = new Date().toISOString();
-  const evidence: InspectorGroupEvidence = {
-    jsonPath: jsonPath(group.id),
-    markdownPath: markdownPath(group.id),
-    htmlPath: htmlPath(group.id),
-    exportedAt,
-  };
-  const documentGroup: InspectorGroup = {
-    ...group,
-    evidence,
-    updatedAt: exportedAt,
-  };
-  const summary = buildSummary(members);
-  const jenkinsReport = buildJenkinsReport(documentGroup, summary);
-  const document: GroupEvidenceDocument = {
-    group: documentGroup,
-    evidence,
-    members,
-    summary,
-    jenkinsReport,
-  };
-  const markdown = buildMarkdown(document);
-
-  assert(
-    ensurePrivateDirectorySync(groupEvidenceDir(group.id)),
-    "Could not secure group evidence directory",
-  );
-  writeFileSync(evidence.jsonPath, `${JSON.stringify(document, null, 2)}\n`, {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  writeFileSync(evidence.markdownPath, markdown, {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  writeFileSync(evidence.htmlPath, buildHtml(markdown, group.title), {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  for (const path of [evidence.jsonPath, evidence.markdownPath, evidence.htmlPath]) {
-    assert(securePrivateFileSync(path), `Could not secure group evidence file ${path}`);
-  }
-
-  const updatedGroup = updateGroupEvidence(group.id, evidence) ?? documentGroup;
-  return { ...document, group: updatedGroup };
-}
-
-export function readGroupEvidenceMarkdown(group: InspectorGroup): string | null {
-  const path = group.evidence?.markdownPath;
-  if (path === undefined || !existsSync(path)) return null;
-  try {
-    return readFileSync(path, "utf8");
-  } catch {
-    return null;
-  }
-}
-
-export function readGroupEvidenceDocument(group: InspectorGroup): GroupEvidenceExportResult | null {
-  const path = group.evidence?.jsonPath;
-  if (path === undefined) return null;
-  const result = readJsonFile(path, GroupEvidenceExportResultSchema);
-  return result.ok ? result.data : null;
-}