@tonyclaw/agent-inspector 2.0.25 → 2.0.27

package/src/mcp/toolHandlers.ts

@@ -17,6 +17,14 @@ import { Buffer } from "node:buffer";
 import { z } from "zod";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
+import {
+  EvidenceExportResultSchema,
+  InspectorRunSchema,
+  RecentFailuresResponseSchema,
+  type CreateInspectorRunInput,
+  type UpdateInspectorRunInput,
+} from "../lib/runContract";
+import { SessionInfoSchema } from "../lib/sessionInfoContract";
 import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
 
 /** Minimal callApi contract: same shape as the real `callApi` in loopback.ts. */
@@ -36,6 +44,15 @@ const LogsListResponseSchema = z.object({
   limit: z.number().optional(),
 });
 
+const SearchLogsResponseSchema = z.object({
+  query: z.string(),
+  logs: z.array(CapturedLogSchema),
+  total: z.number(),
+  offset: z.number(),
+  limit: z.number(),
+  scanned: z.number().optional(),
+});
+
 const PAGINATION_DEFAULTS = { offset: 0, limit: 3 };
 export const LIMIT_HARD_CAP = 5;
 const LOG_DETAIL_TEXT_LIMIT = 200_000;
@@ -168,6 +185,47 @@ export async function listLogsImpl(callApi: CallApiFn, args: ListLogsArgs): Prom
   return textJson(logs.map(buildLogSummary));
 }
 
+export type SearchLogsArgs = {
+  query?: string;
+  offset?: number;
+  limit?: number;
+  scanLimit?: number;
+  sessionId?: string;
+  model?: string;
+};
+
+export async function searchLogsImpl(
+  callApi: CallApiFn,
+  args: SearchLogsArgs,
+): Promise<ToolResult> {
+  const offset = args.offset ?? PAGINATION_DEFAULTS.offset;
+  const limit = clampLimit(args.limit);
+  const params = new URLSearchParams({
+    q: args.query ?? "",
+    offset: String(offset),
+    limit: String(limit),
+  });
+  if (args.scanLimit !== undefined) {
+    params.set("scanLimit", String(args.scanLimit));
+  }
+  if (args.sessionId !== undefined && args.sessionId.length > 0) {
+    params.set("sessionId", args.sessionId);
+  }
+  if (args.model !== undefined && args.model.length > 0) {
+    params.set("model", args.model);
+  }
+
+  const res = await callApi(`/api/logs?${params.toString()}`);
+  if (!res.ok) return toolError(`GET /api/logs search returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = SearchLogsResponseSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/logs search returned an unparseable shape");
+  return textJson({
+    ...parsed.data,
+    logs: parsed.data.logs.map(buildLogSummary),
+  });
+}
+
 export async function getLogImpl(callApi: CallApiFn, id: number): Promise<ToolResult> {
   const res = await callApi(`/api/logs/${id}`);
   if (!res.ok) return toolError(`GET /api/logs/${id} returned ${res.status}`);
@@ -191,6 +249,129 @@ export async function listSessionsImpl(callApi: CallApiFn): Promise<ToolResult>
   return textJson(await res.json());
 }
 
+export type GetSessionArgs = {
+  sessionId: string;
+  includeHistory?: boolean;
+  latestLogLimit?: number;
+};
+
+export async function getSessionImpl(
+  callApi: CallApiFn,
+  args: GetSessionArgs,
+): Promise<ToolResult> {
+  const params = new URLSearchParams({ sessionId: args.sessionId });
+  if (args.latestLogLimit !== undefined) {
+    params.set("limit", String(args.latestLogLimit));
+  }
+  if (args.includeHistory === true) {
+    params.set("includeHistory", "1");
+  }
+  const path = `/api/sessions?${params.toString()}`;
+  const res = await callApi(path);
+  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = SessionInfoSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/sessions returned an unparseable session info");
+  return textJson(parsed.data);
+}
+
+export async function createRunImpl(
+  callApi: CallApiFn,
+  args: CreateInspectorRunInput,
+): Promise<ToolResult> {
+  const res = await callApi("/api/runs", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args ?? {}),
+  });
+  if (!res.ok) return toolError(`POST /api/runs returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("POST /api/runs returned an unparseable run");
+  return textJson(parsed.data);
+}
+
+export type GetRunArgs = {
+  runId: string;
+};
+
+export async function getRunImpl(callApi: CallApiFn, args: GetRunArgs): Promise<ToolResult> {
+  const path = `/api/runs/${encodeURIComponent(args.runId)}`;
+  const res = await callApi(path);
+  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/runs/{runId} returned an unparseable run");
+  return textJson(parsed.data);
+}
+
+export type UpdateRunArgs = {
+  runId: string;
+} & UpdateInspectorRunInput;
+
+export async function updateRunImpl(callApi: CallApiFn, args: UpdateRunArgs): Promise<ToolResult> {
+  const { runId, ...patch } = args;
+  const path = `/api/runs/${encodeURIComponent(runId)}`;
+  const res = await callApi(path, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(patch),
+  });
+  if (!res.ok) return toolError(`PATCH ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("PATCH /api/runs/{runId} returned an unparseable run");
+  return textJson(parsed.data);
+}
+
+export type GetRecentFailuresArgs = {
+  limit?: number;
+};
+
+export async function getRecentFailuresImpl(
+  callApi: CallApiFn,
+  args: GetRecentFailuresArgs,
+): Promise<ToolResult> {
+  const limit = args.limit ?? 5;
+  const params = new URLSearchParams({ failures: "1", limit: String(limit) });
+  const res = await callApi(`/api/runs?${params.toString()}`);
+  if (!res.ok) return toolError(`GET /api/runs?failures=1 returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = RecentFailuresResponseSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError("GET /api/runs?failures=1 returned an unparseable failure list");
+  }
+  return textJson(parsed.data);
+}
+
+export type ExportEvidenceArgs = {
+  runId: string;
+  includeHistory?: boolean;
+  latestLogLimit?: number;
+};
+
+export async function exportEvidenceImpl(
+  callApi: CallApiFn,
+  args: ExportEvidenceArgs,
+): Promise<ToolResult> {
+  const path = `/api/runs/${encodeURIComponent(args.runId)}/evidence`;
+  const res = await callApi(path, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      includeHistory: args.includeHistory,
+      latestLogLimit: args.latestLogLimit,
+    }),
+  });
+  if (!res.ok) return toolError(`POST ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = EvidenceExportResultSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError("POST /api/runs/{runId}/evidence returned an unparseable evidence result");
+  }
+  return textJson(parsed.data);
+}
+
 export async function listModelsImpl(callApi: CallApiFn): Promise<ToolResult> {
   const res = await callApi("/api/models");
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);