@tonyclaw/agent-inspector 2.0.41 → 2.0.42

package/src/mcp/server.ts

@@ -33,8 +33,10 @@ import {
   UpdateInspectorGroupInputSchema,
 } from "../lib/groupContract";
 import { InspectorRunStatusSchema, UpdateInspectorRunInputSchema } from "../lib/runContract";
-import { setCurrentPort } from "../lib/serverPort";
+import { getCurrentPort, setCurrentPort } from "../lib/serverPort";
 import { JsonValueSchema } from "../contracts";
+import { getCurrentContext } from "./currentContext";
+import { getMcpModeInfo, isMcpWriteEnabled } from "./mode";
 import {
   getInspectorGroup,
   listInspectorGroups,
@@ -51,17 +53,24 @@ import { callApi } from "./loopback";
 import {
   addGroupSessionImpl,
   addProviderImpl,
+  diagnoseProviderTestImpl,
+  exportEvidenceBundleImpl,
   createGroupImpl,
   createRunImpl,
   createSessionKnowledgeImpl,
   deleteGroupImpl,
   exportEvidenceImpl,
+  getCurrentContextImpl,
+  getEvidenceFilesImpl,
   exportGroupEvidenceImpl,
+  exportGroupEvidenceBundleImpl,
+  getGroupEvidenceFilesImpl,
   getGroupImpl,
   getRecentFailuresImpl,
   getProjectContextImpl,
   getRunImpl,
   getSessionImpl,
+  getSessionTimelineImpl,
   getLogChunksImpl,
   getLogImpl,
   getProviderImpl,
@@ -76,10 +85,12 @@ import {
   safeCall,
   searchLogsImpl,
   searchKnowledgeImpl,
+  setCurrentContextImpl,
   testProviderImpl,
   updateGroupImpl,
   updateRunImpl,
   updateProviderImpl,
+  type ToolResult,
 } from "./toolHandlers";
 
 // ---------------------------------------------------------------------------
@@ -206,6 +217,140 @@ function jsonResource(uri: URL, data: unknown): ReadResourceResult {
   return textResource(uri, "application/json", JSON.stringify(data, null, 2));
 }
 
+function mcpEndpointUrl(): string {
+  return `http://localhost:${String(getCurrentPort())}/api/mcp`;
+}
+
+function mcpHealth(): Record<string, unknown> {
+  return {
+    status: "ok",
+    serverInfo: {
+      name: "agent-inspector",
+      version: MCP_SERVER_VERSION,
+    },
+    transport: {
+      primary: "streamable-http",
+      endpoint: "/api/mcp",
+      stateless: true,
+    },
+    mode: getMcpModeInfo(),
+    catalog: {
+      tools: TOOL_NAMES.length,
+      resources: RESOURCE_NAMES.length,
+      prompts: PROMPT_NAMES.length,
+    },
+  };
+}
+
+const WRITE_TOOL_NAMES = new Set<string>([
+  "inspector_create_run",
+  "inspector_update_run",
+  "inspector_export_evidence",
+  "inspector_export_evidence_bundle",
+  "inspector_create_group",
+  "inspector_update_group",
+  "inspector_delete_group",
+  "inspector_add_group_session",
+  "inspector_export_group_evidence",
+  "inspector_export_group_evidence_bundle",
+  "inspector_set_current_context",
+  "inspector_replay_log",
+  "inspector_add_provider",
+  "inspector_update_provider",
+  "inspector_test_provider",
+  "inspector_diagnose_provider_test",
+  "inspector_create_session_knowledge",
+  "inspector_promote_knowledge_candidate",
+]);
+
+function mcpCapabilities(): Record<string, unknown> {
+  const readTools = TOOL_NAMES.filter((name) => !WRITE_TOOL_NAMES.has(name));
+  const writeTools = TOOL_NAMES.filter((name) => WRITE_TOOL_NAMES.has(name));
+  return {
+    serverInfo: {
+      name: "agent-inspector",
+      version: MCP_SERVER_VERSION,
+    },
+    mode: getMcpModeInfo(),
+    tools: {
+      read: readTools,
+      writeOrAction: writeTools,
+    },
+    resources: RESOURCE_NAMES,
+    prompts: PROMPT_NAMES,
+  };
+}
+
+function mcpConfig(): Record<string, unknown> {
+  const endpoint = mcpEndpointUrl();
+  return {
+    streamableHttp: {
+      endpoint,
+      config: {
+        mcpServers: {
+          "agent-inspector": {
+            type: "streamableHttp",
+            url: endpoint,
+          },
+        },
+      },
+    },
+    stdioBridge: {
+      command: "agent-inspector-mcp",
+      args: ["stdio", "--url", endpoint],
+      config: {
+        mcpServers: {
+          "agent-inspector": {
+            command: "agent-inspector-mcp",
+            args: ["stdio", "--url", endpoint],
+          },
+        },
+      },
+    },
+    opencodeLocal: {
+      mcp: {
+        "agent-inspector": {
+          type: "local",
+          command: ["agent-inspector-mcp", "stdio", "--url", endpoint],
+          enabled: true,
+        },
+      },
+    },
+    networkNote:
+      "If the MCP client runs in another container or host, replace localhost with an address reachable from that client. Configure only one transport for the same Inspector instance.",
+  };
+}
+
+function disabledWriteTool(toolName: string): ToolResult {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            error: "mcp-write-disabled",
+            tool: toolName,
+            mode: getMcpModeInfo(),
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+    isError: true,
+  };
+}
+
+function safeWriteCall(
+  toolName: string,
+  fn: () => ToolResult | Promise<ToolResult>,
+): Promise<ToolResult> {
+  return safeCall(() => {
+    if (!isMcpWriteEnabled()) return disabledWriteTool(toolName);
+    return fn();
+  });
+}
+
 function variableString(variables: Variables, name: string): string | null {
   const value = variables[name];
   if (Array.isArray(value)) return value[0] ?? null;
@@ -256,6 +401,25 @@ async function listSessionResources(): Promise<ListResourcesResult> {
   }
 }
 
+async function listSessionTimelineResources(): Promise<ListResourcesResult> {
+  try {
+    const response = await callApi("/api/sessions");
+    if (!response.ok) return listResult([]);
+    const parsed = z.array(z.string()).safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.map((sessionId) => ({
+        uri: `inspector://sessions/${encodeURIComponent(sessionId)}/timeline`,
+        name: `session-timeline:${sessionId}`,
+        title: `Inspector session ${sessionId} timeline`,
+        mimeType: "application/json",
+      })),
+    );
+  } catch {
+    return listResult([]);
+  }
+}
+
 async function listLogResources(): Promise<ListResourcesResult> {
   try {
     const response = await callApi("/api/logs?offset=0&limit=5&compact=1");
@@ -322,6 +486,20 @@ function listGroupEvidenceResources(): ListResourcesResult {
   );
 }
 
+function listGroupEvidenceFileResources(): ListResourcesResult {
+  return listResult(
+    listInspectorGroups()
+      .groups.filter((group) => group.evidence !== null)
+      .map((group) => ({
+        uri: `inspector://groups/${encodeURIComponent(group.id)}/evidence/files`,
+        name: `group-evidence-files:${group.id}`,
+        title: `${group.title} evidence files`,
+        mimeType: "application/json",
+        description: group.evidence?.jsonPath,
+      })),
+  );
+}
+
 function listEvidenceResources(): ListResourcesResult {
   return listResult(
     listInspectorRuns()
@@ -336,6 +514,20 @@ function listEvidenceResources(): ListResourcesResult {
   );
 }
 
+function listEvidenceFileResources(): ListResourcesResult {
+  return listResult(
+    listInspectorRuns()
+      .runs.filter((run) => run.evidence !== null)
+      .map((run) => ({
+        uri: `inspector://evidence/${encodeURIComponent(run.id)}/files`,
+        name: `evidence-files:${run.id}`,
+        title: `${run.title} evidence files`,
+        mimeType: "application/json",
+        description: run.evidence?.jsonPath,
+      })),
+  );
+}
+
 function userPrompt(text: string): GetPromptResult {
   return {
     messages: [
@@ -470,6 +662,59 @@ function registerTools(server: McpServer): void {
     (args) => safeCall(() => getSessionImpl(callApi, args)),
   );
 
+  server.registerTool(
+    "inspector_get_session_timeline",
+    {
+      title: "Get Inspector session timeline",
+      description:
+        "Returns a bounded chronological request timeline for one session with log ids, provider/model labels, statuses, latency, streaming timing, token usage, and previews. Use this when an agent needs the shape of a session before opening large logs.",
+      inputSchema: z.object({
+        sessionId: z.string().min(1).describe("The Inspector session id."),
+        offset: z.number().int().nonnegative().optional().describe("Skip this many matching logs."),
+        limit: z
+          .number()
+          .int()
+          .positive()
+          .max(50)
+          .optional()
+          .describe("Maximum timeline events to return. Default 20, max 50."),
+      }),
+    },
+    (args) => safeCall(() => getSessionTimelineImpl(callApi, args)),
+  );
+
+  server.registerTool(
+    "inspector_get_current_context",
+    {
+      title: "Get current Inspector MCP context",
+      description:
+        "Returns the current MCP context that an evaluator or coding agent can set to bind subsequent work to a group, run, session, model, provider, project, or task.",
+      inputSchema: z.object({}),
+    },
+    () => safeCall(() => getCurrentContextImpl()),
+  );
+
+  server.registerTool(
+    "inspector_set_current_context",
+    {
+      title: "Set current Inspector MCP context",
+      description:
+        "Updates the current MCP context for this local Inspector process. Use this at the start of a benchmark/eval turn so later tools can discover the active group/run/session labels.",
+      inputSchema: z.object({
+        groupId: z.string().min(1).nullable().optional(),
+        runId: z.string().min(1).nullable().optional(),
+        sessionId: z.string().min(1).nullable().optional(),
+        model: z.string().min(1).nullable().optional(),
+        provider: z.string().min(1).nullable().optional(),
+        agent: z.string().min(1).nullable().optional(),
+        project: z.string().min(1).nullable().optional(),
+        task: z.string().min(1).nullable().optional(),
+        metadata: z.record(z.string(), JsonValueSchema).optional(),
+      }),
+    },
+    (args) => safeWriteCall("inspector_set_current_context", () => setCurrentContextImpl(args)),
+  );
+
   server.registerTool(
     "inspector_create_run",
     {
@@ -483,6 +728,14 @@ function registerTools(server: McpServer): void {
           .min(1)
           .optional()
           .describe("Inspector session id to attach. Defaults to the run id."),
+        groupId: z
+          .string()
+          .min(1)
+          .nullable()
+          .optional()
+          .describe(
+            "Optional group id. When set with a real sessionId, the run is auto-attached to that group.",
+          ),
         title: z.string().min(1).optional().describe("Human-readable run title."),
         task: z.string().nullable().optional().describe("Task statement or benchmark case."),
         project: z.string().nullable().optional().describe("Project or repository under test."),
@@ -492,7 +745,7 @@ function registerTools(server: McpServer): void {
         metadata: z.record(z.string(), JsonValueSchema).optional().describe("JSON metadata."),
       }),
     },
-    (args) => safeCall(() => createRunImpl(args)),
+    (args) => safeWriteCall("inspector_create_run", () => createRunImpl(args)),
   );
 
   server.registerTool(
@@ -518,7 +771,7 @@ function registerTools(server: McpServer): void {
         runId: z.string().min(1).describe("The Inspector run id."),
       }),
     },
-    (args) => safeCall(() => updateRunImpl(args)),
+    (args) => safeWriteCall("inspector_update_run", () => updateRunImpl(args)),
   );
 
   server.registerTool(
@@ -542,7 +795,34 @@ function registerTools(server: McpServer): void {
           .describe("How many compact log summaries to include in the evidence pack. Max 50."),
       }),
     },
-    (args) => safeCall(() => exportEvidenceImpl(args)),
+    (args) => safeWriteCall("inspector_export_evidence", () => exportEvidenceImpl(args)),
+  );
+
+  server.registerTool(
+    "inspector_get_evidence_files",
+    {
+      title: "Get run evidence file paths",
+      description:
+        "Returns the local JSON, Markdown, HTML, and byte-size status for an already exported run evidence pack. It does not create new files.",
+      inputSchema: z.object({
+        runId: z.string().min(1).describe("The Inspector run id."),
+      }),
+    },
+    (args) => safeCall(() => getEvidenceFilesImpl(args)),
+  );
+
+  server.registerTool(
+    "inspector_export_evidence_bundle",
+    {
+      title: "Export run evidence ZIP bundle",
+      description:
+        "Creates evidence.zip next to an already exported run evidence pack, bundling evidence.json, evidence.md, evidence.html, and a manifest.",
+      inputSchema: z.object({
+        runId: z.string().min(1).describe("The Inspector run id."),
+      }),
+    },
+    (args) =>
+      safeWriteCall("inspector_export_evidence_bundle", () => exportEvidenceBundleImpl(args)),
   );
 
   server.registerTool(
@@ -595,7 +875,7 @@ function registerTools(server: McpServer): void {
         metadata: z.record(z.string(), JsonValueSchema).optional().describe("JSON metadata."),
       }),
     },
-    (args) => safeCall(() => createGroupImpl(args)),
+    (args) => safeWriteCall("inspector_create_group", () => createGroupImpl(args)),
   );
 
   server.registerTool(
@@ -621,7 +901,7 @@ function registerTools(server: McpServer): void {
         groupId: z.string().min(1).describe("The Inspector group id."),
       }),
     },
-    (args) => safeCall(() => updateGroupImpl(args)),
+    (args) => safeWriteCall("inspector_update_group", () => updateGroupImpl(args)),
   );
 
   server.registerTool(
@@ -634,7 +914,7 @@ function registerTools(server: McpServer): void {
         groupId: z.string().min(1).describe("The Inspector group id."),
       }),
     },
-    (args) => safeCall(() => deleteGroupImpl(args)),
+    (args) => safeWriteCall("inspector_delete_group", () => deleteGroupImpl(args)),
   );
 
   server.registerTool(
@@ -647,7 +927,7 @@ function registerTools(server: McpServer): void {
         groupId: z.string().min(1).describe("The Inspector group id."),
       }),
     },
-    (args) => safeCall(() => addGroupSessionImpl(args)),
+    (args) => safeWriteCall("inspector_add_group_session", () => addGroupSessionImpl(args)),
   );
 
   server.registerTool(
@@ -660,7 +940,36 @@ function registerTools(server: McpServer): void {
         groupId: z.string().min(1).describe("The Inspector group id."),
       }),
     },
-    (args) => safeCall(() => exportGroupEvidenceImpl(args)),
+    (args) => safeWriteCall("inspector_export_group_evidence", () => exportGroupEvidenceImpl(args)),
+  );
+
+  server.registerTool(
+    "inspector_get_group_evidence_files",
+    {
+      title: "Get group evidence file paths",
+      description:
+        "Returns the local JSON, Markdown, HTML, and byte-size status for an already exported group evidence pack. It does not create new files.",
+      inputSchema: z.object({
+        groupId: z.string().min(1).describe("The Inspector group id."),
+      }),
+    },
+    (args) => safeCall(() => getGroupEvidenceFilesImpl(args)),
+  );
+
+  server.registerTool(
+    "inspector_export_group_evidence_bundle",
+    {
+      title: "Export group evidence ZIP bundle",
+      description:
+        "Creates group-evidence.zip next to an already exported group evidence pack, bundling evidence.json, evidence.md, evidence.html, and a manifest.",
+      inputSchema: z.object({
+        groupId: z.string().min(1).describe("The Inspector group id."),
+      }),
+    },
+    (args) =>
+      safeWriteCall("inspector_export_group_evidence_bundle", () =>
+        exportGroupEvidenceBundleImpl(args),
+      ),
   );
 
   server.registerTool(
@@ -718,7 +1027,7 @@ function registerTools(server: McpServer): void {
         id: z.number().int().positive().describe("The log id to replay."),
       }),
     },
-    (args) => safeCall(() => replayLogImpl(callApi, args)),
+    (args) => safeWriteCall("inspector_replay_log", () => replayLogImpl(callApi, args)),
   );
 
   // ----- Provider write tools -----
@@ -739,7 +1048,7 @@ function registerTools(server: McpServer): void {
         apiDocsUrl: z.string().optional(),
       }),
     },
-    (provider) => safeCall(() => addProviderImpl(callApi, provider)),
+    (provider) => safeWriteCall("inspector_add_provider", () => addProviderImpl(callApi, provider)),
   );
 
   server.registerTool(
@@ -762,7 +1071,7 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         apiDocsUrl: z.string().optional(),
       }),
     },
-    (input) => safeCall(() => updateProviderImpl(callApi, input)),
+    (input) => safeWriteCall("inspector_update_provider", () => updateProviderImpl(callApi, input)),
   );
 
   server.registerTool(
@@ -775,7 +1084,23 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         id: z.string().describe("The provider id to test."),
       }),
     },
-    ({ id }) => safeCall(() => testProviderImpl(callApi, id)),
+    ({ id }) => safeWriteCall("inspector_test_provider", () => testProviderImpl(callApi, id)),
+  );
+
+  server.registerTool(
+    "inspector_diagnose_provider_test",
+    {
+      title: "Run provider test with diagnostics",
+      description:
+        "Runs Provider Test and returns the raw result plus MCP-friendly diagnostic issues and hints for timeout, auth, base URL, container networking, and non-streaming/streaming mismatches.",
+      inputSchema: z.object({
+        id: z.string().describe("The provider id to test."),
+      }),
+    },
+    ({ id }) =>
+      safeWriteCall("inspector_diagnose_provider_test", () =>
+        diagnoseProviderTestImpl(callApi, id),
+      ),
   );
 
   // ----- Knowledge bridge tools -----
@@ -790,7 +1115,10 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         sessionId: z.string().min(1).describe("The Inspector session id to distill."),
       }),
     },
-    (args) => safeCall(() => createSessionKnowledgeImpl(callApi, args)),
+    (args) =>
+      safeWriteCall("inspector_create_session_knowledge", () =>
+        createSessionKnowledgeImpl(callApi, args),
+      ),
   );
 
   server.registerTool(
@@ -814,7 +1142,10 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         candidateId: z.string().min(1).describe("The candidate id to promote."),
       }),
     },
-    (args) => safeCall(() => promoteKnowledgeCandidateImpl(callApi, args)),
+    (args) =>
+      safeWriteCall("inspector_promote_knowledge_candidate", () =>
+        promoteKnowledgeCandidateImpl(callApi, args),
+      ),
   );
 
   server.registerTool(
@@ -846,6 +1177,50 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
 }
 
 function registerResources(server: McpServer): void {
+  server.registerResource(
+    "inspector_mcp_health",
+    "inspector://mcp/health",
+    {
+      title: "Inspector MCP health",
+      description: "MCP server version, transport, mode, and catalog counts.",
+      mimeType: "application/json",
+    },
+    (uri) => jsonResource(uri, mcpHealth()),
+  );
+
+  server.registerResource(
+    "inspector_mcp_capabilities",
+    "inspector://mcp/capabilities",
+    {
+      title: "Inspector MCP capabilities",
+      description: "Machine-readable Inspector MCP tools, resources, prompts, and write mode.",
+      mimeType: "application/json",
+    },
+    (uri) => jsonResource(uri, mcpCapabilities()),
+  );
+
+  server.registerResource(
+    "inspector_mcp_config",
+    "inspector://mcp/config",
+    {
+      title: "Inspector MCP client config",
+      description: "Streamable HTTP, stdio bridge, and OpenCode MCP configuration snippets.",
+      mimeType: "application/json",
+    },
+    (uri) => jsonResource(uri, mcpConfig()),
+  );
+
+  server.registerResource(
+    "inspector_current_context",
+    "inspector://context/current",
+    {
+      title: "Inspector current context",
+      description: "Current group/run/session/model/provider context set through MCP.",
+      mimeType: "application/json",
+    },
+    (uri) => jsonResource(uri, getCurrentContext()),
+  );
+
   server.registerResource(
     "inspector_sessions",
     "inspector://sessions",
@@ -874,6 +1249,27 @@ function registerResources(server: McpServer): void {
     },
   );
 
+  server.registerResource(
+    "inspector_session_timeline",
+    new ResourceTemplate("inspector://sessions/{sessionId}/timeline", {
+      list: listSessionTimelineResources,
+    }),
+    {
+      title: "Inspector session timeline",
+      description:
+        "Bounded chronological request timeline for a session with log ids, timings, status, tokens, and previews.",
+      mimeType: "application/json",
+    },
+    async (uri, variables) => {
+      const sessionId = variableString(variables, "sessionId");
+      if (sessionId === null) return textResource(uri, "text/plain", "Missing sessionId");
+      const result = await getSessionTimelineImpl(callApi, { sessionId, limit: 50 });
+      const first = result.content[0];
+      const text = first?.text ?? "";
+      return textResource(uri, result.isError === true ? "text/plain" : "application/json", text);
+    },
+  );
+
   server.registerResource(
     "inspector_log",
     new ResourceTemplate("inspector://logs/{id}", { list: listLogResources }),
@@ -994,6 +1390,26 @@ function registerResources(server: McpServer): void {
     },
   );
 
+  server.registerResource(
+    "inspector_evidence_files",
+    new ResourceTemplate("inspector://evidence/{runId}/files", {
+      list: listEvidenceFileResources,
+    }),
+    {
+      title: "Inspector evidence files",
+      description: "Local file paths and byte sizes for a run evidence pack.",
+      mimeType: "application/json",
+    },
+    (uri, variables) => {
+      const runId = variableString(variables, "runId");
+      if (runId === null) return textResource(uri, "text/plain", "Missing runId");
+      const result = getEvidenceFilesImpl({ runId });
+      const first = result.content[0];
+      const text = first?.text ?? "";
+      return textResource(uri, result.isError === true ? "text/plain" : "application/json", text);
+    },
+  );
+
   server.registerResource(
     "inspector_group_evidence",
     new ResourceTemplate("inspector://groups/{groupId}/evidence", {
@@ -1013,6 +1429,26 @@ function registerResources(server: McpServer): void {
       return textResource(uri, "text/markdown", evidence.value.markdown);
     },
   );
+
+  server.registerResource(
+    "inspector_group_evidence_files",
+    new ResourceTemplate("inspector://groups/{groupId}/evidence/files", {
+      list: listGroupEvidenceFileResources,
+    }),
+    {
+      title: "Inspector group evidence files",
+      description: "Local file paths and byte sizes for a group evidence pack.",
+      mimeType: "application/json",
+    },
+    (uri, variables) => {
+      const groupId = variableString(variables, "groupId");
+      if (groupId === null) return textResource(uri, "text/plain", "Missing groupId");
+      const result = getGroupEvidenceFilesImpl({ groupId });
+      const first = result.content[0];
+      const text = first?.text ?? "";
+      return textResource(uri, result.isError === true ? "text/plain" : "application/json", text);
+    },
+  );
 }
 
 function registerPrompts(server: McpServer): void {
@@ -1167,10 +1603,15 @@ export const TOOL_NAMES = [
   "inspector_get_log_chunks",
   "inspector_list_sessions",
   "inspector_get_session",
+  "inspector_get_session_timeline",
+  "inspector_get_current_context",
+  "inspector_set_current_context",
   "inspector_create_run",
   "inspector_get_run",
   "inspector_update_run",
   "inspector_export_evidence",
+  "inspector_get_evidence_files",
+  "inspector_export_evidence_bundle",
   "inspector_get_recent_failures",
   "inspector_list_groups",
   "inspector_create_group",
@@ -1179,6 +1620,8 @@ export const TOOL_NAMES = [
   "inspector_delete_group",
   "inspector_add_group_session",
   "inspector_export_group_evidence",
+  "inspector_get_group_evidence_files",
+  "inspector_export_group_evidence_bundle",
   "inspector_list_models",
   "inspector_list_providers",
   "inspector_get_provider",
@@ -1186,6 +1629,7 @@ export const TOOL_NAMES = [
   "inspector_add_provider",
   "inspector_update_provider",
   "inspector_test_provider",
+  "inspector_diagnose_provider_test",
   "inspector_create_session_knowledge",
   "inspector_list_knowledge_candidates",
   "inspector_promote_knowledge_candidate",
@@ -1194,17 +1638,24 @@ export const TOOL_NAMES = [
 ] as const;
 
 export const RESOURCE_NAMES = [
+  "inspector_mcp_health",
+  "inspector_mcp_capabilities",
+  "inspector_mcp_config",
+  "inspector_current_context",
   "inspector_sessions",
   "inspector_session",
+  "inspector_session_timeline",
   "inspector_log",
   "inspector_runs",
   "inspector_recent_failures",
   "inspector_run",
   "inspector_evidence",
+  "inspector_evidence_files",
   "inspector_groups",
   "inspector_group",
   "inspector_group_sessions",
   "inspector_group_evidence",
+  "inspector_group_evidence_files",
 ] as const;
 
 export const PROMPT_NAMES = [