@tonyclaw/agent-inspector 2.0.33 → 2.0.35

package/src/mcp/toolHandlers.ts

@@ -1,9 +1,11 @@
 /**
- * Pure (dependency-injected) tool handler implementations for the MCP
- * server. These are split out from `server.ts` so unit tests can pass a
- * mock `callApi` without spinning up a real HTTP loopback. The
- * `registerTool` calls in `server.ts` simply wrap each impl in `safeCall`
- * and bind the real `callApi` from `./loopback`.
+ * Tool handler implementations for the MCP server. These are split out from
+ * `server.ts` so the wire-level MCP registration stays thin.
+ *
+ * Log/provider/knowledge handlers still use an injected `callApi` while those
+ * domains are being migrated. Run/group/evidence handlers call the shared
+ * service layer directly so MCP and REST API are peers instead of MCP looping
+ * back through `/api/*`.
  *
  * Each impl returns a `CallToolResult`-shaped object: either
  * `{ content: [{ type: "text", text: string }] }` on success or
@@ -15,27 +17,34 @@
 
 import { Buffer } from "node:buffer";
 import { z } from "zod";
+import { getCurrentPort } from "../lib/serverPort";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
 import {
-  DeleteInspectorGroupResponseSchema,
-  GroupEvidenceExportResultSchema,
-  InspectorGroupSchema,
-  InspectorGroupsListResponseSchema,
   type AddInspectorGroupSessionInput,
   type CreateInspectorGroupInput,
   type DeleteInspectorGroupOptions,
   type UpdateInspectorGroupInput,
 } from "../lib/groupContract";
-import {
-  EvidenceExportResultSchema,
-  InspectorRunSchema,
-  RecentFailuresResponseSchema,
-  type CreateInspectorRunInput,
-  type UpdateInspectorRunInput,
-} from "../lib/runContract";
+import { type CreateInspectorRunInput, type UpdateInspectorRunInput } from "../lib/runContract";
 import { SessionInfoSchema } from "../lib/sessionInfoContract";
 import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
+import {
+  addInspectorGroupSession,
+  createInspectorGroup,
+  deleteInspectorGroup,
+  exportInspectorGroupEvidence,
+  getInspectorGroup,
+  listInspectorGroups,
+  updateInspectorGroup,
+} from "../services/groups";
+import {
+  createInspectorRun,
+  exportInspectorRunEvidence,
+  getInspectorRun,
+  listInspectorRecentFailures,
+  updateInspectorRun,
+} from "../services/runs";
 
 /** Minimal callApi contract: same shape as the real `callApi` in loopback.ts. */
 export type CallApiFn = (path: string, options?: CallApiOptions) => Promise<Response>;
@@ -81,6 +90,10 @@ function toolError(message: string): ToolResult {
   return { content: [{ type: "text", text: message }], isError: true };
 }
 
+function inspectorBaseUrl(): string {
+  return `http://127.0.0.1:${String(getCurrentPort())}`;
+}
+
 function textByteLength(value: string | null): number | null {
   if (value === null) return null;
   return Buffer.byteLength(value, "utf8");
@@ -288,73 +301,38 @@ export async function getSessionImpl(
   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 function createRunImpl(args: CreateInspectorRunInput): ToolResult {
+  return textJson(createInspectorRun(args));
 }
 
 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 function getRunImpl(args: GetRunArgs): ToolResult {
+  const run = getInspectorRun(args.runId);
+  if (!run.ok) return toolError(run.message);
+  return textJson(run.value);
 }
 
 export type UpdateRunArgs = {
   runId: string;
 } & UpdateInspectorRunInput;
 
-export async function updateRunImpl(callApi: CallApiFn, args: UpdateRunArgs): Promise<ToolResult> {
+export function updateRunImpl(args: UpdateRunArgs): 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);
+  const run = updateInspectorRun(runId, patch);
+  if (!run.ok) return toolError(run.message);
+  return textJson(run.value);
 }
 
 export type GetRecentFailuresArgs = {
   limit?: number;
 };
 
-export async function getRecentFailuresImpl(
-  callApi: CallApiFn,
-  args: GetRecentFailuresArgs,
-): Promise<ToolResult> {
+export function getRecentFailuresImpl(args: GetRecentFailuresArgs): 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);
+  return textJson(listInspectorRecentFailures(limit));
 }
 
 export type ExportEvidenceArgs = {
@@ -363,133 +341,67 @@ export type ExportEvidenceArgs = {
   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({
+export async function exportEvidenceImpl(args: ExportEvidenceArgs): Promise<ToolResult> {
+  const exported = await exportInspectorRunEvidence(
+    args.runId,
+    {
       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);
+    },
+    inspectorBaseUrl(),
+  );
+  if (!exported.ok) return toolError(exported.message);
+  return textJson(exported.value);
 }
 
-export async function listGroupsImpl(callApi: CallApiFn): Promise<ToolResult> {
-  const res = await callApi("/api/groups");
-  if (!res.ok) return toolError(`GET /api/groups returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = InspectorGroupsListResponseSchema.safeParse(rawBody);
-  if (!parsed.success) return toolError("GET /api/groups returned an unparseable group list");
-  return textJson(parsed.data);
+export function listGroupsImpl(): ToolResult {
+  return textJson(listInspectorGroups());
 }
 
-export async function createGroupImpl(
-  callApi: CallApiFn,
-  args: CreateInspectorGroupInput,
-): Promise<ToolResult> {
-  const res = await callApi("/api/groups", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(args ?? {}),
-  });
-  if (!res.ok) return toolError(`POST /api/groups returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = InspectorGroupSchema.safeParse(rawBody);
-  if (!parsed.success) return toolError("POST /api/groups returned an unparseable group");
-  return textJson(parsed.data);
+export function createGroupImpl(args: CreateInspectorGroupInput): ToolResult {
+  return textJson(createInspectorGroup(args));
 }
 
 export type GetGroupArgs = {
   groupId: string;
 };
 
-export async function getGroupImpl(callApi: CallApiFn, args: GetGroupArgs): Promise<ToolResult> {
-  const path = `/api/groups/${encodeURIComponent(args.groupId)}`;
-  const res = await callApi(path);
-  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = InspectorGroupSchema.safeParse(rawBody);
-  if (!parsed.success) return toolError("GET /api/groups/{groupId} returned an unparseable group");
-  return textJson(parsed.data);
+export function getGroupImpl(args: GetGroupArgs): ToolResult {
+  const group = getInspectorGroup(args.groupId);
+  if (!group.ok) return toolError(group.message);
+  return textJson(group.value);
 }
 
 export type UpdateGroupArgs = {
   groupId: string;
 } & UpdateInspectorGroupInput;
 
-export async function updateGroupImpl(
-  callApi: CallApiFn,
-  args: UpdateGroupArgs,
-): Promise<ToolResult> {
+export function updateGroupImpl(args: UpdateGroupArgs): ToolResult {
   const { groupId, ...patch } = args;
-  const path = `/api/groups/${encodeURIComponent(groupId)}`;
-  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 = InspectorGroupSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError("PATCH /api/groups/{groupId} returned an unparseable group");
-  }
-  return textJson(parsed.data);
+  const group = updateInspectorGroup(groupId, patch);
+  if (!group.ok) return toolError(group.message);
+  return textJson(group.value);
 }
 
 export type DeleteGroupArgs = {
   groupId: string;
 } & DeleteInspectorGroupOptions;
 
-export async function deleteGroupImpl(
-  callApi: CallApiFn,
-  args: DeleteGroupArgs,
-): Promise<ToolResult> {
-  const query = args.deleteEvidence === true ? "?deleteEvidence=1" : "";
-  const path = `/api/groups/${encodeURIComponent(args.groupId)}${query}`;
-  const res = await callApi(path, { method: "DELETE" });
-  if (!res.ok) return toolError(`DELETE ${path} returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = DeleteInspectorGroupResponseSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError("DELETE /api/groups/{groupId} returned an unparseable delete result");
-  }
-  return textJson(parsed.data);
+export function deleteGroupImpl(args: DeleteGroupArgs): ToolResult {
+  const deleted = deleteInspectorGroup(args.groupId, { deleteEvidence: args.deleteEvidence });
+  if (!deleted.ok) return toolError(deleted.message);
+  return textJson(deleted.value);
 }
 
 export type AddGroupSessionArgs = {
   groupId: string;
 } & AddInspectorGroupSessionInput;
 
-export async function addGroupSessionImpl(
-  callApi: CallApiFn,
-  args: AddGroupSessionArgs,
-): Promise<ToolResult> {
+export function addGroupSessionImpl(args: AddGroupSessionArgs): ToolResult {
   const { groupId, ...session } = args;
-  const path = `/api/groups/${encodeURIComponent(groupId)}/sessions`;
-  const res = await callApi(path, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(session),
-  });
-  if (!res.ok) return toolError(`POST ${path} returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = InspectorGroupSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError("POST /api/groups/{groupId}/sessions returned an unparseable group");
-  }
-  return textJson(parsed.data);
+  const group = addInspectorGroupSession(groupId, session);
+  if (!group.ok) return toolError(group.message);
+  return textJson(group.value);
 }
 
 export type ExportGroupEvidenceArgs = {
@@ -498,26 +410,17 @@ export type ExportGroupEvidenceArgs = {
   latestLogLimit?: number;
 };
 
-export async function exportGroupEvidenceImpl(
-  callApi: CallApiFn,
-  args: ExportGroupEvidenceArgs,
-): Promise<ToolResult> {
-  const path = `/api/groups/${encodeURIComponent(args.groupId)}/evidence`;
-  const res = await callApi(path, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
+export async function exportGroupEvidenceImpl(args: ExportGroupEvidenceArgs): Promise<ToolResult> {
+  const exported = await exportInspectorGroupEvidence(
+    args.groupId,
+    {
       includeHistory: args.includeHistory,
       latestLogLimit: args.latestLogLimit,
-    }),
-  });
-  if (!res.ok) return toolError(`POST ${path} returned ${res.status}`);
-  const rawBody: unknown = await res.json();
-  const parsed = GroupEvidenceExportResultSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError("POST /api/groups/{groupId}/evidence returned an unparseable evidence result");
-  }
-  return textJson(parsed.data);
+    },
+    inspectorBaseUrl(),
+  );
+  if (!exported.ok) return toolError(exported.message);
+  return textJson(exported.value);
 }
 
 export async function listModelsImpl(callApi: CallApiFn): Promise<ToolResult> {
@@ -724,7 +627,7 @@ export async function getProjectContextImpl(
  * CallToolResult (instead of a JSON-RPC protocol error, which would abort
  * the whole session). Loopback timeouts get a clear message.
  */
-export async function safeCall(fn: () => Promise<ToolResult>): Promise<ToolResult> {
+export async function safeCall(fn: () => ToolResult | Promise<ToolResult>): Promise<ToolResult> {
   try {
     return await fn();
   } catch (err) {

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

@@ -1,11 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { GroupEvidenceExportOptionsSchema } from "../../lib/groupContract";
-import {
-  exportGroupEvidence,
-  readGroupEvidenceDocument,
-  readGroupEvidenceMarkdown,
-} from "../../proxy/groupEvidenceExporter";
-import { getGroup } from "../../proxy/groupStore";
+import { exportInspectorGroupEvidence, readInspectorGroupEvidence } from "../../services/groups";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 
@@ -23,35 +18,14 @@ export const Route = createFileRoute("/api/groups/$groupId/evidence")({
   server: {
     handlers: {
       GET: ({ params }: { params: { groupId: string } }) => {
-        const group = getGroup(params.groupId);
-        if (group === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const evidence = readInspectorGroupEvidence(params.groupId);
+        if (!evidence.ok) {
+          return Response.json({ error: evidence.message }, { status: evidence.status });
         }
 
-        const markdown = readGroupEvidenceMarkdown(group);
-        if (group.evidence === null || markdown === null) {
-          return Response.json(
-            { error: "Evidence has not been exported for this group" },
-            { status: 404 },
-          );
-        }
-
-        const document = readGroupEvidenceDocument(group);
-
-        return Response.json({
-          group,
-          evidence: group.evidence,
-          markdown,
-          summary: document?.summary ?? null,
-          report: document?.jenkinsReport ?? null,
-        });
+        return Response.json(evidence.value);
       },
       POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
-        const group = getGroup(params.groupId);
-        if (group === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
-        }
-
         const body = await readJsonBody(request);
         if (!body.ok) {
           return Response.json({ error: "Invalid JSON body" }, { status: 400 });
@@ -65,9 +39,16 @@ export const Route = createFileRoute("/api/groups/$groupId/evidence")({
           );
         }
 
-        return Response.json(
-          await exportGroupEvidence(group, parsed.data, new URL(request.url).origin),
+        const exported = await exportInspectorGroupEvidence(
+          params.groupId,
+          parsed.data,
+          new URL(request.url).origin,
         );
+        if (!exported.ok) {
+          return Response.json({ error: exported.message }, { status: exported.status });
+        }
+
+        return Response.json(exported.value);
       },
     },
   },

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

@@ -1,6 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { AddInspectorGroupSessionInputSchema } from "../../lib/groupContract";
-import { addGroupSession, getGroup } from "../../proxy/groupStore";
+import { addInspectorGroupSession, readInspectorGroupSessions } from "../../services/groups";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 
@@ -18,11 +18,11 @@ export const Route = createFileRoute("/api/groups/$groupId/sessions")({
   server: {
     handlers: {
       GET: ({ params }: { params: { groupId: string } }) => {
-        const group = getGroup(params.groupId);
-        if (group === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const sessions = readInspectorGroupSessions(params.groupId);
+        if (!sessions.ok) {
+          return Response.json({ error: sessions.message }, { status: sessions.status });
         }
-        return Response.json({ groupId: group.id, members: group.members });
+        return Response.json(sessions.value);
       },
       POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
         const body = await readJsonBody(request);
@@ -38,12 +38,12 @@ export const Route = createFileRoute("/api/groups/$groupId/sessions")({
           );
         }
 
-        const updated = addGroupSession(params.groupId, parsed.data);
-        if (updated === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const updated = addInspectorGroupSession(params.groupId, parsed.data);
+        if (!updated.ok) {
+          return Response.json({ error: updated.message }, { status: updated.status });
         }
 
-        return Response.json(updated);
+        return Response.json(updated.value);
       },
     },
   },

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

@@ -1,6 +1,10 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { UpdateInspectorGroupInputSchema } from "../../lib/groupContract";
-import { deleteGroup, getGroup, updateGroup } from "../../proxy/groupStore";
+import {
+  deleteInspectorGroup,
+  getInspectorGroup,
+  updateInspectorGroup,
+} from "../../services/groups";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 type DeleteEvidenceFlagResult = { ok: true; value: boolean | undefined } | { ok: false };
@@ -39,11 +43,11 @@ export const Route = createFileRoute("/api/groups/$groupId")({
   server: {
     handlers: {
       GET: ({ params }: { params: { groupId: string } }) => {
-        const group = getGroup(params.groupId);
-        if (group === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const group = getInspectorGroup(params.groupId);
+        if (!group.ok) {
+          return Response.json({ error: group.message }, { status: group.status });
         }
-        return Response.json(group);
+        return Response.json(group.value);
       },
       PATCH: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
         const body = await readJsonBody(request);
@@ -59,12 +63,12 @@ export const Route = createFileRoute("/api/groups/$groupId")({
           );
         }
 
-        const updated = updateGroup(params.groupId, parsed.data);
-        if (updated === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const updated = updateInspectorGroup(params.groupId, parsed.data);
+        if (!updated.ok) {
+          return Response.json({ error: updated.message }, { status: updated.status });
         }
 
-        return Response.json(updated);
+        return Response.json(updated.value);
       },
       DELETE: ({ params, request }: { params: { groupId: string }; request: Request }) => {
         const deleteEvidence = readDeleteEvidenceFlag(request);
@@ -75,12 +79,14 @@ export const Route = createFileRoute("/api/groups/$groupId")({
           );
         }
 
-        const deleted = deleteGroup(params.groupId, { deleteEvidence: deleteEvidence.value });
-        if (deleted === null) {
-          return Response.json({ error: "Group not found" }, { status: 404 });
+        const deleted = deleteInspectorGroup(params.groupId, {
+          deleteEvidence: deleteEvidence.value,
+        });
+        if (!deleted.ok) {
+          return Response.json({ error: deleted.message }, { status: deleted.status });
         }
 
-        return Response.json(deleted);
+        return Response.json(deleted.value);
       },
     },
   },

package/src/routes/api/groups.ts

@@ -1,6 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { CreateInspectorGroupInputSchema } from "../../lib/groupContract";
-import { createGroup, listGroups } from "../../proxy/groupStore";
+import { createInspectorGroup, listInspectorGroups } from "../../services/groups";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 
@@ -17,7 +17,7 @@ async function readJsonBody(request: Request): Promise<JsonBodyResult> {
 export const Route = createFileRoute("/api/groups")({
   server: {
     handlers: {
-      GET: () => Response.json({ groups: listGroups() }),
+      GET: () => Response.json(listInspectorGroups()),
       POST: async ({ request }: { request: Request }) => {
         const body = await readJsonBody(request);
         if (!body.ok) {
@@ -32,7 +32,7 @@ export const Route = createFileRoute("/api/groups")({
           );
         }
 
-        return Response.json(createGroup(parsed.data), { status: 201 });
+        return Response.json(createInspectorGroup(parsed.data), { status: 201 });
       },
     },
   },

package/src/routes/api/runs.$runId.evidence.ts

@@ -1,7 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { EvidenceExportOptionsSchema } from "../../lib/runContract";
-import { exportRunEvidence, readEvidenceMarkdown } from "../../proxy/evidenceExporter";
-import { getRun } from "../../proxy/runStore";
+import { exportInspectorRunEvidence, readInspectorRunEvidence } from "../../services/runs";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 
@@ -19,27 +18,14 @@ export const Route = createFileRoute("/api/runs/$runId/evidence")({
   server: {
     handlers: {
       GET: ({ params }: { params: { runId: string } }) => {
-        const run = getRun(params.runId);
-        if (run === null) {
-          return Response.json({ error: "Run not found" }, { status: 404 });
+        const evidence = readInspectorRunEvidence(params.runId);
+        if (!evidence.ok) {
+          return Response.json({ error: evidence.message }, { status: evidence.status });
         }
 
-        const markdown = readEvidenceMarkdown(run);
-        if (run.evidence === null || markdown === null) {
-          return Response.json(
-            { error: "Evidence has not been exported for this run" },
-            { status: 404 },
-          );
-        }
-
-        return Response.json({ run, evidence: run.evidence, markdown });
+        return Response.json(evidence.value);
       },
       POST: async ({ params, request }: { params: { runId: string }; request: Request }) => {
-        const run = getRun(params.runId);
-        if (run === null) {
-          return Response.json({ error: "Run not found" }, { status: 404 });
-        }
-
         const body = await readJsonBody(request);
         if (!body.ok) {
           return Response.json({ error: "Invalid JSON body" }, { status: 400 });
@@ -53,9 +39,16 @@ export const Route = createFileRoute("/api/runs/$runId/evidence")({
           );
         }
 
-        return Response.json(
-          await exportRunEvidence(run, parsed.data, new URL(request.url).origin),
+        const exported = await exportInspectorRunEvidence(
+          params.runId,
+          parsed.data,
+          new URL(request.url).origin,
         );
+        if (!exported.ok) {
+          return Response.json({ error: exported.message }, { status: exported.status });
+        }
+
+        return Response.json(exported.value);
       },
     },
   },

package/src/routes/api/runs.$runId.ts

@@ -1,6 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { UpdateInspectorRunInputSchema } from "../../lib/runContract";
-import { getRun, updateRun } from "../../proxy/runStore";
+import { getInspectorRun, updateInspectorRun } from "../../services/runs";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
 
@@ -18,11 +18,11 @@ export const Route = createFileRoute("/api/runs/$runId")({
   server: {
     handlers: {
       GET: ({ params }: { params: { runId: string } }) => {
-        const run = getRun(params.runId);
-        if (run === null) {
-          return Response.json({ error: "Run not found" }, { status: 404 });
+        const run = getInspectorRun(params.runId);
+        if (!run.ok) {
+          return Response.json({ error: run.message }, { status: run.status });
         }
-        return Response.json(run);
+        return Response.json(run.value);
       },
       PATCH: async ({ params, request }: { params: { runId: string }; request: Request }) => {
         const body = await readJsonBody(request);
@@ -38,12 +38,12 @@ export const Route = createFileRoute("/api/runs/$runId")({
           );
         }
 
-        const updated = updateRun(params.runId, parsed.data);
-        if (updated === null) {
-          return Response.json({ error: "Run not found" }, { status: 404 });
+        const updated = updateInspectorRun(params.runId, parsed.data);
+        if (!updated.ok) {
+          return Response.json({ error: updated.message }, { status: updated.status });
         }
 
-        return Response.json(updated);
+        return Response.json(updated.value);
       },
     },
   },