@tonyclaw/agent-inspector 2.0.30 → 2.0.31

package/src/lib/groupContract.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { JsonValueSchema } from "../proxy/schemas";
-import { InspectorRunSchema, InspectorRunStatusSchema, JenkinsReportSchema } from "./runContract";
+import { EvidenceReportSchema, InspectorRunSchema, InspectorRunStatusSchema } from "./runContract";
 import { SessionInfoSchema, SessionTokenUsageSchema } from "./sessionInfoContract";
 
 export const InspectorGroupStatusSchema = z.enum([
@@ -112,12 +112,20 @@ export const InspectorGroupEvidenceSummarySchema = z.object({
   runningMembers: z.number().int().nonnegative(),
 });
 
+export const GroupEvidenceReadResponseSchema = z.object({
+  group: InspectorGroupSchema,
+  evidence: InspectorGroupEvidenceSchema,
+  markdown: z.string(),
+  summary: InspectorGroupEvidenceSummarySchema.nullable(),
+  report: EvidenceReportSchema.nullable(),
+});
+
 export const GroupEvidenceExportResultSchema = z.object({
   group: InspectorGroupSchema,
   evidence: InspectorGroupEvidenceSchema,
   members: z.array(InspectorGroupExportMemberSchema),
   summary: InspectorGroupEvidenceSummarySchema,
-  jenkinsReport: JenkinsReportSchema,
+  jenkinsReport: EvidenceReportSchema,
 });
 
 export const InspectorGroupsListResponseSchema = z.object({
@@ -135,5 +143,6 @@ export type AddInspectorGroupSessionInput = z.infer<typeof AddInspectorGroupSess
 export type GroupEvidenceExportOptions = z.infer<typeof GroupEvidenceExportOptionsSchema>;
 export type InspectorGroupExportMember = z.infer<typeof InspectorGroupExportMemberSchema>;
 export type InspectorGroupEvidenceSummary = z.infer<typeof InspectorGroupEvidenceSummarySchema>;
+export type GroupEvidenceReadResponse = z.infer<typeof GroupEvidenceReadResponseSchema>;
 export type GroupEvidenceExportResult = z.infer<typeof GroupEvidenceExportResultSchema>;
 export type InspectorGroupsListResponse = z.infer<typeof InspectorGroupsListResponseSchema>;

package/src/lib/runContract.ts

@@ -71,6 +71,7 @@ export const JenkinsReportSchema = z.object({
   summary: z.string(),
   markdown: z.string(),
 });
+export const EvidenceReportSchema = JenkinsReportSchema;
 
 export const InspectorRunSchema = z.object({
   id: z.string(),
@@ -153,6 +154,7 @@ export type RunTimelineEvent = z.infer<typeof RunTimelineEventSchema>;
 export type FailureCategory = z.infer<typeof FailureCategorySchema>;
 export type FailureClassification = z.infer<typeof FailureClassificationSchema>;
 export type JenkinsReport = z.infer<typeof JenkinsReportSchema>;
+export type EvidenceReport = JenkinsReport;
 export type InspectorRun = z.infer<typeof InspectorRunSchema>;
 export type CreateInspectorRunInput = z.infer<typeof CreateInspectorRunInputSchema>;
 export type UpdateInspectorRunInput = z.infer<typeof UpdateInspectorRunInputSchema>;

package/src/lib/useGroupEvidence.ts

@@ -0,0 +1,33 @@
+import useSWR, { type SWRResponse } from "swr";
+import {
+  GroupEvidenceReadResponseSchema,
+  type GroupEvidenceReadResponse,
+  type InspectorGroup,
+} from "./groupContract";
+import { fetchJson } from "./apiClient";
+
+type UseGroupEvidenceResult = {
+  evidenceResponse: GroupEvidenceReadResponse | null;
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: SWRResponse<GroupEvidenceReadResponse, Error>["mutate"];
+};
+
+function evidenceKey(group: InspectorGroup | null): string | null {
+  if (group === null || group.evidence === null) return null;
+  return `/api/groups/${encodeURIComponent(group.id)}/evidence`;
+}
+
+export function useGroupEvidence(group: InspectorGroup | null): UseGroupEvidenceResult {
+  const response: SWRResponse<GroupEvidenceReadResponse, Error> = useSWR<
+    GroupEvidenceReadResponse,
+    Error
+  >(evidenceKey(group), (url: string) => fetchJson(url, GroupEvidenceReadResponseSchema));
+
+  return {
+    evidenceResponse: response.data ?? null,
+    isLoading: response.isLoading,
+    error: response.error,
+    mutate: response.mutate,
+  };
+}

package/src/lib/useGroups.ts

@@ -0,0 +1,28 @@
+import useSWR, { type SWRResponse } from "swr";
+import {
+  InspectorGroupsListResponseSchema,
+  type InspectorGroup,
+  type InspectorGroupsListResponse,
+} from "./groupContract";
+import { fetchJson } from "./apiClient";
+
+type UseGroupsResult = {
+  groups: InspectorGroup[];
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: SWRResponse<InspectorGroupsListResponse, Error>["mutate"];
+};
+
+export function useGroups(): UseGroupsResult {
+  const response: SWRResponse<InspectorGroupsListResponse, Error> = useSWR<
+    InspectorGroupsListResponse,
+    Error
+  >("/api/groups", (url: string) => fetchJson(url, InspectorGroupsListResponseSchema));
+
+  return {
+    groups: response.data?.groups ?? [],
+    isLoading: response.isLoading,
+    error: response.error,
+    mutate: response.mutate,
+  };
+}

package/src/mcp/server.ts

@@ -16,6 +16,7 @@
  */
 
 import { z } from "zod";
+import packageJson from "../../package.json";
 import {
   type GetPromptResult,
   type ListResourcesResult,
@@ -80,12 +81,14 @@ import {
 
 type ServerPair = { server: McpServer; transport: WebStandardStreamableHTTPServerTransport };
 
+export const MCP_SERVER_VERSION = packageJson.version;
+
 let initialized: ServerPair | null = null;
 let initPromise: Promise<ServerPair> | null = null;
 
 function buildServer(): ServerPair {
   const server = new McpServer(
-    { name: "agent-inspector", version: "1.0.0" },
+    { name: "agent-inspector", version: MCP_SERVER_VERSION },
     { capabilities: { tools: {}, resources: {}, prompts: {} } },
   );
   registerTools(server);

package/src/proxy/groupEvidenceExporter.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
+  GroupEvidenceExportResultSchema,
   type GroupEvidenceExportOptions,
   type GroupEvidenceExportResult,
   type InspectorGroup,
@@ -339,3 +340,15 @@ export function readGroupEvidenceMarkdown(group: InspectorGroup): string | null
     return null;
   }
 }
+
+export function readGroupEvidenceDocument(group: InspectorGroup): GroupEvidenceExportResult | null {
+  const path = group.evidence?.jsonPath;
+  if (path === undefined || !existsSync(path)) return null;
+  try {
+    const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = GroupEvidenceExportResultSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}

package/src/routes/api/groups.$groupId.evidence.ts

@@ -1,6 +1,10 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { GroupEvidenceExportOptionsSchema } from "../../lib/groupContract";
-import { exportGroupEvidence, readGroupEvidenceMarkdown } from "../../proxy/groupEvidenceExporter";
+import {
+  exportGroupEvidence,
+  readGroupEvidenceDocument,
+  readGroupEvidenceMarkdown,
+} from "../../proxy/groupEvidenceExporter";
 import { getGroup } from "../../proxy/groupStore";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
@@ -32,7 +36,15 @@ export const Route = createFileRoute("/api/groups/$groupId/evidence")({
           );
         }
 
-        return Response.json({ group, evidence: group.evidence, markdown });
+        const document = readGroupEvidenceDocument(group);
+
+        return Response.json({
+          group,
+          evidence: group.evidence,
+          markdown,
+          summary: document?.summary ?? null,
+          report: document?.jenkinsReport ?? null,
+        });
       },
       POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
         const group = getGroup(params.groupId);