@axiom-lattice/gateway 2.1.111 → 2.1.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.111",
+  "version": "2.1.112",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -41,11 +41,10 @@
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
     "zod": "3.25.76",
-    "@axiom-lattice/agent-eval": "2.1.92",
-    "@axiom-lattice/core": "2.1.98",
-    "@axiom-lattice/pg-stores": "1.0.89",
-    "@axiom-lattice/protocols": "2.1.50",
-    "@axiom-lattice/queue-redis": "1.0.49"
+    "@axiom-lattice/core": "2.1.99",
+    "@axiom-lattice/pg-stores": "1.0.90",
+    "@axiom-lattice/protocols": "2.1.51",
+    "@axiom-lattice/queue-redis": "1.0.50"
   },
   "devDependencies": {
     "@types/bcrypt": "^6.0.0",

package/src/controllers/__tests__/workflow-tracking.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+
+const mockQueryWorkflowRuns = jest.fn();
+const mockGetRunSteps = jest.fn();
+const mockGetAllAssistants = jest.fn();
+const mockGetAgent = jest.fn();
+
+jest.mock("@axiom-lattice/core", () => ({
+  getStoreLattice: (_key: string, type: string) =>
+    type === "workflowTracking"
+      ? { store: { queryWorkflowRuns: mockQueryWorkflowRuns, getRunSteps: mockGetRunSteps } }
+      : { store: { getAllAssistants: mockGetAllAssistants } },
+  agentInstanceManager: { getAgent: mockGetAgent },
+  ThreadStatus: { IDLE: "IDLE", BUSY: "BUSY", INTERRUPTED: "INTERRUPTED" },
+}));
+
+function makeRun(id: string, startedAt: string) {
+  return {
+    id,
+    tenantId: "t1",
+    assistantId: "a1",
+    threadId: `th_${id}`,
+    status: "interrupted" as const,
+    topologyEdges: [],
+    totalEdges: 2,
+    completedEdges: 1,
+    startedAt: new Date(startedAt),
+    createdAt: new Date(startedAt),
+    updatedAt: new Date(startedAt),
+  };
+}
+
+function makeRequest(query: Record<string, string> = {}) {
+  return {
+    headers: { "x-tenant-id": "t1" },
+    query,
+    log: { error: jest.fn(), warn: jest.fn() },
+  } as never;
+}
+
+const mockReply = { status: jest.fn().mockReturnThis(), send: jest.fn() } as never;
+
+describe("getInboxItems", () => {
+  let getInboxItems: (req: never, reply: never) => Promise<{ data?: Record<string, unknown> }>;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    mockGetAllAssistants.mockResolvedValue([{ id: "a1", name: "Assistant One" }] as never);
+    mockGetRunSteps.mockResolvedValue([] as never);
+    mockGetAgent.mockImplementation(() => { throw new Error("no agent"); }); // fallback path
+    const mod = await import("../../controllers/workflow-tracking");
+    getInboxItems = mod.getInboxItems as never;
+  });
+
+  it("legacy mode: no query params returns all items without pagination fields", async () => {
+    mockQueryWorkflowRuns.mockResolvedValue({
+      records: [makeRun("r1", "2026-01-01"), makeRun("r2", "2026-01-02")],
+      total: 2,
+    } as never);
+
+    const res = await getInboxItems(makeRequest(), mockReply);
+
+    expect(mockQueryWorkflowRuns).toHaveBeenCalledWith("t1", { status: "interrupted" });
+    expect(res.data).toBeDefined();
+    const records = res.data!.records as unknown[];
+    expect(records).toHaveLength(2);
+    expect(res.data!.total).toBeUndefined();
+    expect(res.data!.page).toBeUndefined();
+  });
+
+  it("paged mode: passes limit/offset to store and returns total/page/pageSize", async () => {
+    mockQueryWorkflowRuns.mockResolvedValue({
+      records: [makeRun("r3", "2026-01-03")],
+      total: 42,
+    } as never);
+
+    const res = await getInboxItems(makeRequest({ page: "2", pageSize: "20" }), mockReply);
+
+    expect(mockQueryWorkflowRuns).toHaveBeenCalledWith("t1", { status: "interrupted", limit: 20, offset: 20 });
+    expect(res.data!.total).toBe(42);
+    expect(res.data!.page).toBe(2);
+    expect(res.data!.pageSize).toBe(20);
+    expect(res.data!.records).toHaveLength(1);
+  });
+
+  it("paged mode triggers when only pageSize is passed", async () => {
+    mockQueryWorkflowRuns.mockResolvedValue({ records: [], total: 0 } as never);
+
+    const res = await getInboxItems(makeRequest({ pageSize: "10" }), mockReply);
+
+    expect(mockQueryWorkflowRuns).toHaveBeenCalledWith("t1", { status: "interrupted", limit: 10, offset: 0 });
+    expect(res.data!.page).toBe(1);
+    expect(res.data!.pageSize).toBe(10);
+  });
+
+  it("sanitizes invalid page and caps pageSize at 100", async () => {
+    mockQueryWorkflowRuns.mockResolvedValue({ records: [], total: 0 } as never);
+
+    const res = await getInboxItems(makeRequest({ page: "abc", pageSize: "500" }), mockReply);
+
+    expect(mockQueryWorkflowRuns).toHaveBeenCalledWith("t1", { status: "interrupted", limit: 100, offset: 0 });
+    expect(res.data!.page).toBe(1);
+    expect(res.data!.pageSize).toBe(100);
+  });
+
+  it("returns empty records with pagination fields in paged mode", async () => {
+    mockQueryWorkflowRuns.mockResolvedValue({ records: [], total: 0 } as never);
+
+    const res = await getInboxItems(makeRequest({ page: "3", pageSize: "20" }), mockReply);
+
+    expect(res.data).toEqual({ records: [], total: 0, page: 3, pageSize: 20 });
+  });
+});

package/src/controllers/connections.ts

@@ -16,6 +16,13 @@ const testOrDiscoverBody = z.object({
 });
 
 function getTenant(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
   return (request.headers["x-tenant-id"] as string) || "default";
 }
 

package/src/controllers/eval.ts

@@ -25,12 +25,27 @@ export async function createProject(
     const store = getEvalStore();
     const id = uuidv4();
     const data = request.body as any;
+    const serverCfg = (data.targetServerConfig || {}) as Record<string, unknown>;
+    const judgeCfg = (data.judgeModelConfig || {}) as Record<string, unknown>;
+    const modelKey = (judgeCfg.modelKey as string) || "";
+    if (modelKey) {
+      const { modelLatticeManager } = await import("@axiom-lattice/core");
+      if (!modelLatticeManager.hasLattice(modelKey)) {
+        return reply.status(400).send({ success: false, message: `Judge model "${modelKey}" is not registered` });
+      }
+    }
     const project = await store.createProject(tenantId, id, {
       name: data.name,
       description: data.description,
       version: data.version,
-      judgeModelConfig: data.judgeModelConfig ?? {},
-      targetServerConfig: data.targetServerConfig ?? {},
+      judgeModelConfig: {
+        modelKey,
+        displayName: (judgeCfg.displayName as string) || "",
+      },
+      targetServerConfig: {
+        base_url: (serverCfg.base_url as string) || "",
+        api_key: (serverCfg.api_key as string) || "",
+      },
       concurrency: data.concurrency ?? 1,
       reportConfig: data.reportConfig,
     });
@@ -62,7 +77,7 @@ export async function listProjects(
         const first = models[0];
         const judgeModel = first
           ? { modelKey: first.key }
-          : { provider: "openai", model: "gpt-4" };
+          : {};
 
         const host = request.hostname || "localhost";
         const baseUrl = `http://${host}:${process.env.PORT || 4001}`;
@@ -125,7 +140,32 @@ export async function updateProject(
     if (!existing) {
       return reply.status(404).send({ success: false, message: "Project not found" });
     }
-    const updated = await store.updateProject(tenantId, pid, request.body as any);
+    const body = request.body as Record<string, unknown>;
+    const updateData: Record<string, unknown> = { ...body };
+    // Strip in_process from user input — it is server-controlled
+    const serverCfg = (body.targetServerConfig || {}) as Record<string, unknown>;
+    if (body.targetServerConfig !== undefined) {
+      updateData.targetServerConfig = {
+        base_url: (serverCfg.base_url as string) || "",
+        api_key: (serverCfg.api_key as string) || "",
+      };
+    }
+    // Only allow modelKey/displayName — never raw provider/apiKey/baseURL
+    if (body.judgeModelConfig !== undefined) {
+      const judgeCfg = (body.judgeModelConfig || {}) as Record<string, unknown>;
+      const modelKey = (judgeCfg.modelKey as string) || "";
+      if (modelKey) {
+        const { modelLatticeManager } = await import("@axiom-lattice/core");
+        if (!modelLatticeManager.hasLattice(modelKey)) {
+          return reply.status(400).send({ success: false, message: `Judge model "${modelKey}" is not registered` });
+        }
+      }
+      updateData.judgeModelConfig = {
+        modelKey,
+        displayName: (judgeCfg.displayName as string) || "",
+      };
+    }
+    const updated = await store.updateProject(tenantId, pid, updateData);
     return {
       success: true,
       message: "Successfully updated project",

package/src/controllers/workflow-tracking.ts

@@ -1,5 +1,5 @@
 import { FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice, agentInstanceManager, ThreadStatus } from "@axiom-lattice/core";
+import { getStoreLattice, agentInstanceManager, ThreadStatus, abortWorkflowRun as signalAbort } from "@axiom-lattice/core";
 import type { WorkflowTrackingStore, WorkflowRun, RunStep } from "@axiom-lattice/protocols";
 import { MessageChunkTypes } from "@axiom-lattice/protocols";
 
@@ -189,10 +189,18 @@ export async function getAllWorkflowRuns(
 }
 
 // GET /api/workflows/inbox
+// Pagination semantics:
+// - No page/pageSize → legacy mode: all interrupted items, data = { records } (unchanged shape).
+// - page and/or pageSize → paged mode: store-level pagination over interrupted runs,
+//   data = { records, total, page, pageSize }. total = number of interrupted RUNS
+//   (each run expands to 0..N inbox items after the agent-state check).
+const INBOX_DEFAULT_PAGE_SIZE = 20;
+const INBOX_MAX_PAGE_SIZE = 100;
+
 export async function getInboxItems(
-  request: FastifyRequest,
+  request: FastifyRequest<{ Querystring: { page?: string; pageSize?: string } }>,
   reply: FastifyReply
-): Promise<ApiResponse<{ records: any[] }>> {
+): Promise<ApiResponse<{ records: any[]; total?: number; page?: number; pageSize?: number }>> {
   const tenantId = getTenantId(request);
 
   try {
@@ -214,10 +222,32 @@ export async function getInboxItems(
       // names unavailable, will fall back to ID
     }
 
-    const runs = await store.getWorkflowRunsByTenantId(tenantId);
-    const pendingRuns = runs.filter(r => r.status === "interrupted");
+    const { page: pageParam, pageSize: pageSizeParam } = request.query;
+    const paged = pageParam !== undefined || pageSizeParam !== undefined;
+    const page = Math.max(1, parseInt(pageParam ?? "", 10) || 1);
+    const pageSize = Math.min(INBOX_MAX_PAGE_SIZE, Math.max(1, parseInt(pageSizeParam ?? "", 10) || INBOX_DEFAULT_PAGE_SIZE));
+
+    let pendingRuns: WorkflowRun[];
+    let total: number | undefined;
+    if (paged) {
+      const result = await store.queryWorkflowRuns(tenantId, {
+        status: "interrupted",
+        limit: pageSize,
+        offset: (page - 1) * pageSize,
+      });
+      pendingRuns = result.records;
+      total = result.total;
+    } else {
+      const result = await store.queryWorkflowRuns(tenantId, { status: "interrupted" });
+      pendingRuns = result.records;
+    }
+
     if (pendingRuns.length === 0) {
-      return { success: true, message: "No pending workflows", data: { records: [] } };
+      return {
+        success: true,
+        message: "No pending workflows",
+        data: paged ? { records: [], total, page, pageSize } : { records: [] },
+      };
     }
 
     // Parallelize agent checks across interrupted workflows
@@ -283,15 +313,13 @@ export async function getInboxItems(
 
     const results = await Promise.all(checkPromises);
     const inboxItems = results.flat();
-
-    inboxItems.sort((a, b) =>
-      new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
-    );
+    // Runs are already sorted by updatedAt DESC, id DESC from queryWorkflowRuns.
+    // flatMap preserves run order within each run.
 
     return {
       success: true,
       message: "Successfully retrieved inbox items",
-      data: { records: inboxItems },
+      data: paged ? { records: inboxItems, total, page, pageSize } : { records: inboxItems },
     };
   } catch (error) {
     request.log.error(error, "Failed to get inbox items");
@@ -597,3 +625,69 @@ export async function replyInboxTask(
     });
   }
 }
+
+/**
+ * Abort a running workflow.
+ *
+ * Stops the main graph execution AND signals all in-progress
+ * sub-agent invokes to cancel.
+ */
+export async function abortWorkflowRun(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<void> {
+  try {
+    const { runId } = request.params as { runId: string };
+    const tenantId = getTenantId(request);
+
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({
+        success: false,
+        message: "No workflow tracking store configured",
+      });
+    }
+
+    const run = await store.getWorkflowRun(runId);
+    if (!run) {
+      return reply.status(404).send({
+        success: false,
+        message: "Workflow run not found",
+      });
+    }
+
+    // Persist abort intent FIRST — prevents restart after server crash
+    await store.updateWorkflowRun(runId, {
+      status: "cancelled",
+      errorMessage: "Aborted by user",
+      completedAt: new Date(),
+    }).catch(() => {});
+
+    // Stop the main graph execution
+    const workspace_id = request.headers["x-workspace-id"] as string;
+    const project_id = request.headers["x-project-id"] as string;
+    const agent = agentInstanceManager.getAgent({
+      assistant_id: run.assistantId,
+      thread_id: run.threadId,
+      tenant_id: tenantId,
+      workspace_id,
+      project_id,
+    });
+    await agent.abort();
+
+    // Signal sub-agents via AbortController registry
+    signalAbort(runId);
+
+    return reply.status(200).send({
+      success: true,
+      message: "Workflow aborted",
+      data: { runId, assistantId: run.assistantId, threadId: run.threadId },
+    });
+  } catch (error) {
+    request.log.error(error, "Failed to abort workflow run");
+    return reply.status(500).send({
+      success: false,
+      message: `Abort failed: ${(error as Error).message}`,
+    });
+  }
+}

package/src/index.ts

@@ -12,10 +12,11 @@ import type { ChannelInstallationStore, BindingRegistry } from "@axiom-lattice/p
 import { MessageRouter } from "./router/MessageRouter";
 import { ChannelAdapterRegistry } from "./channels/registry";
 import { createDeduplicationMiddleware, createRateLimitMiddleware, createAuditLoggerMiddleware } from "./router/middlewares";
-import { setBindingRegistry, setMenuRegistry } from "@axiom-lattice/core";
+import { setBindingRegistry, setMenuRegistry, setEvalRunService } from "@axiom-lattice/core";
 import { larkChannelAdapter } from "./channels/lark/LarkChannelAdapter";
 import { extractUserFromAuthHeader } from "./controllers/auth";
 import { setChannelControllerDeps } from "./controllers/channel-installations";
+import { evalRunner } from "./services/eval-runner";
 import { configureSwagger } from "./swagger";
 import {
   setQueueServiceType,
@@ -387,6 +388,8 @@ const start = async (config?: LatticeGatewayConfig) => {
       });
     }
 
+    setEvalRunService(evalRunner);
+
     // Initialize MenuRegistry for custom menu items
     try {
       const menuStore = getStoreLattice("default", "menu").store;
@@ -466,13 +469,16 @@ const start = async (config?: LatticeGatewayConfig) => {
     }
 
     // Restore agent instances with pending messages (fire-and-forget to avoid blocking startup)
-    agentInstanceManager.restore()
-      .then((stats) => {
-        logger.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-      })
-      .catch((error) => {
-        logger.error("Agent recovery failed", { error });
-      });
+    // Temporarily disabled: do not auto-consume pending messages on startup.
+    if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
+      agentInstanceManager.restore()
+        .then((stats) => {
+          logger.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
+        })
+        .catch((error) => {
+          logger.error("Agent recovery failed", { error });
+        });
+    }
 
     // Restore MCP server connections that were connected before shutdown
     restoreMcpConnections().catch((error) => {

package/src/routes/index.ts

@@ -510,7 +510,9 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     workflowTrackingController.getAllWorkflowRuns
   );
 
-  app.get(
+  app.get<{
+    Querystring: { page?: string; pageSize?: string };
+  }>(
     "/api/workflows/inbox",
     workflowTrackingController.getInboxItems
   );
@@ -546,6 +548,11 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     Params: { runId: string };
   }>("/api/workflows/runs/:runId/tasks", workflowTrackingController.getRunTasks);
 
+  // Abort a running workflow — stops graph + all sub-agents
+  app.post<{
+    Params: { runId: string };
+  }>("/api/workflows/runs/:runId/abort", workflowTrackingController.abortWorkflowRun);
+
   // 简化的 Inbox 任务回复接口（后台 streaming 执行，立即返回）
   app.post<{
     Body: { runId: string; answers: Array<{ questionIndex: number; selectedOptions: string[] }> };

package/src/services/eval-runner.ts

@@ -1,6 +1,9 @@
 import { EventEmitter } from "events";
-import { getStoreLattice, modelLatticeManager } from "@axiom-lattice/core";
-import { LatticeEvalProject } from "@axiom-lattice/agent-eval";
+import {
+  getStoreLattice,
+  modelLatticeManager,
+  LatticeEvalProject,
+} from "@axiom-lattice/core";
 import type { EvalStore } from "@axiom-lattice/protocols";
 import type {
   CaseRunResult,
@@ -8,8 +11,7 @@ import type {
   LatticeEvalProjectType,
   LatticeEvalSuiteType,
   LatticeEvalLogEvent,
-  OutputType,
-} from "@axiom-lattice/agent-eval";
+} from "@axiom-lattice/core";
 import { v4 as uuidv4 } from "uuid";
 
 export interface EvalStreamEvent {
@@ -48,6 +50,12 @@ class EvalRunner {
     const project = await store.getProjectById(tenantId, projectId);
     if (!project) throw new Error("Project not found");
 
+    for (const ctx of this.runs.values()) {
+      if (ctx.projectId === projectId) {
+        throw new Error("A run is already in progress for this project");
+      }
+    }
+
     const existingRuns = await store.getRunsByTenant(tenantId, { projectId, status: "running" });
     if (existingRuns.length > 0) {
       throw new Error("A run is already in progress for this project");
@@ -65,8 +73,8 @@ class EvalRunner {
         cases: cases.map((c) => ({
           caseId: c.id,
           input: { message: c.inputMessage, files: c.inputFiles },
-          steps: c.steps as Array<{ agent_id: string; override_message?: string }>,
-          output: { type: c.outputType } as OutputType,
+          steps: c.steps,
+          output: { type: "message_content" },
           eval: {
             content_assertion: c.contentAssertion,
             eval_rubrics: c.rubrics?.map((r) => ({
@@ -79,39 +87,35 @@ class EvalRunner {
       });
     }
 
-    const runId = uuidv4();
-    const concurrency = (project as unknown as Record<string, unknown>).concurrency as number || 3;
-    await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
-
-    const judgeCfg = project.judgeModelConfig as Record<string, unknown>;
-    const hasModelKey = Boolean(judgeCfg.modelKey);
-    const hasApiKey = Boolean(judgeCfg.apiKeyEnvName || judgeCfg.apiKey);
-    const hasCredentials = hasApiKey;
-
-    let judgeModelConfig: { modelKey?: string; model?: any } = {};
+    const judgeCfg = (project.judgeModelConfig ?? {}) as Record<string, unknown>;
+    const judgeModelKey = (judgeCfg.modelKey as string) || "";
+    let resolvedJudgeModelKey: string;
 
-    if (hasModelKey) {
-      judgeModelConfig = { modelKey: judgeCfg.modelKey as string };
-    } else if (!hasCredentials) {
-      const firstModel = modelLatticeManager.getAllLattices()[0];
-      if (firstModel) {
-        judgeModelConfig = { modelKey: firstModel.key };
-      } else {
-        judgeModelConfig = { model: judgeCfg as any };
+    if (judgeModelKey) {
+      if (!modelLatticeManager.hasLattice(judgeModelKey)) {
+        throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
+      resolvedJudgeModelKey = judgeModelKey;
     } else {
-      judgeModelConfig = { model: judgeCfg as any };
+      const firstModel = modelLatticeManager.getAllLattices()[0];
+      if (!firstModel) {
+        throw new Error("No model registered — cannot run eval without a judge model");
+      }
+      resolvedJudgeModelKey = firstModel.key;
+      console.warn(`[eval-runner] Project "${project.name}" has no judge modelKey — falling back to first registered model "${firstModel.key}"`);
     }
 
+    const runId = uuidv4();
+    const concurrency = Math.max(1, Math.floor((project as unknown as Record<string, unknown>).concurrency as number) || 3);
+    await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
+
     const projectConfig: LatticeEvalProjectType = {
       projectName: project.name,
       version: project.version,
       description: project.description,
       suites: evalSuites,
-      judge_agent_config: judgeModelConfig,
+      judge_agent_config: { modelKey: resolvedJudgeModelKey },
       lattice_server_config: {
-        base_url: (project.targetServerConfig as Record<string, string>).base_url || "",
-        api_key: (project.targetServerConfig as Record<string, string>).api_key || "",
         tenant_id: tenantId,
       },
       concurrency,
@@ -163,37 +167,41 @@ class EvalRunner {
     const runPromise = (async () => {
       try {
         const evalProject = new LatticeEvalProject(projectConfig, onCaseComplete);
-        const { report } = await evalProject.runAllSuitesBatch(concurrency);
-
-        const completedCount = stats.passed + stats.failed;
-        await store.updateRunStatus(tenantId, runId, {
-          status: "completed",
-          completedAt: new Date(),
-          passedCases: stats.passed,
-          failedCases: stats.failed,
-          avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0,
-        });
-
-        this.eventEmitter.emit(`run:${runId}`, {
-          type: "completed",
-          runId,
-          data: { passed: stats.passed, failed: stats.failed, avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0 },
-        } satisfies EvalStreamEvent);
+        const { report } = await evalProject.runAllSuitesBatch(concurrency, abortController.signal);
+
+        if (!abortController.signal.aborted) {
+          const completedCount = stats.passed + stats.failed;
+          await store.updateRunStatus(tenantId, runId, {
+            status: "completed",
+            completedAt: new Date(),
+            passedCases: stats.passed,
+            failedCases: stats.failed,
+            avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0,
+          });
+
+          this.eventEmitter.emit(`run:${runId}`, {
+            type: "completed",
+            runId,
+            data: { passed: stats.passed, failed: stats.failed, avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0 },
+          } satisfies EvalStreamEvent);
+        }
 
         return { report };
       } catch (err) {
         const errorMsg = (err as Error).message;
-        await store.updateRunStatus(tenantId, runId, {
-          status: "failed",
-          error: errorMsg,
-          completedAt: new Date(),
-        });
-
-        this.eventEmitter.emit(`run:${runId}`, {
-          type: "error",
-          runId,
-          data: { message: errorMsg },
-        } satisfies EvalStreamEvent);
+        if (!abortController.signal.aborted) {
+          await store.updateRunStatus(tenantId, runId, {
+            status: "failed",
+            error: errorMsg,
+            completedAt: new Date(),
+          });
+
+          this.eventEmitter.emit(`run:${runId}`, {
+            type: "error",
+            runId,
+            data: { message: errorMsg },
+          } satisfies EvalStreamEvent);
+        }
 
         throw err;
       } finally {