@axiom-lattice/gateway 2.1.111 → 2.1.112

package/dist/index.mjs

@@ -2227,7 +2227,7 @@ async function executeSqlQuery(client, body, reply) {
 }
 
 // src/controllers/workflow-tracking.ts
-import { getStoreLattice as getStoreLattice4, agentInstanceManager as agentInstanceManager4, ThreadStatus as ThreadStatus2 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice4, agentInstanceManager as agentInstanceManager4, ThreadStatus as ThreadStatus2, abortWorkflowRun as signalAbort } from "@axiom-lattice/core";
 import { MessageChunkTypes as MessageChunkTypes2 } from "@axiom-lattice/protocols";
 function getTenantId7(request) {
   const userTenantId = request.user?.tenantId;
@@ -2366,6 +2366,8 @@ async function getAllWorkflowRuns(request, reply) {
     });
   }
 }
+var INBOX_DEFAULT_PAGE_SIZE = 20;
+var INBOX_MAX_PAGE_SIZE = 100;
 async function getInboxItems(request, reply) {
   const tenantId = getTenantId7(request);
   try {
@@ -2383,10 +2385,30 @@ async function getInboxItems(request, reply) {
       }
     } catch {
     }
-    const runs = await store.getWorkflowRunsByTenantId(tenantId);
-    const pendingRuns = runs.filter((r) => r.status === "interrupted");
+    const { page: pageParam, pageSize: pageSizeParam } = request.query;
+    const paged = pageParam !== void 0 || pageSizeParam !== void 0;
+    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;
+    let total;
+    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: [] }
+      };
     }
     const checkPromises = pendingRuns.map(async (r) => {
       try {
@@ -2443,13 +2465,10 @@ async function getInboxItems(request, reply) {
     });
     const results = await Promise.all(checkPromises);
     const inboxItems = results.flat();
-    inboxItems.sort(
-      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
-    );
     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");
@@ -2682,6 +2701,54 @@ async function replyInboxTask(request, reply) {
     });
   }
 }
+async function abortWorkflowRun(request, reply) {
+  try {
+    const { runId } = request.params;
+    const tenantId = getTenantId7(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"
+      });
+    }
+    await store.updateWorkflowRun(runId, {
+      status: "cancelled",
+      errorMessage: "Aborted by user",
+      completedAt: /* @__PURE__ */ new Date()
+    }).catch(() => {
+    });
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
+    const agent = agentInstanceManager4.getAgent({
+      assistant_id: run.assistantId,
+      thread_id: run.threadId,
+      tenant_id: tenantId,
+      workspace_id,
+      project_id
+    });
+    await agent.abort();
+    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.message}`
+    });
+  }
+}
 
 // src/controllers/personal-assistant.ts
 import { getStoreLattice as getStoreLattice5, PersonalAssistantConfig } from "@axiom-lattice/core";
@@ -5026,6 +5093,10 @@ var testOrDiscoverBody = z.object({
   config: z.record(z.unknown()).optional()
 });
 function getTenant(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
   return request.headers["x-tenant-id"] || "default";
 }
 function maskSecrets(config) {
@@ -5171,8 +5242,11 @@ import { v4 as uuidv44 } from "uuid";
 
 // src/services/eval-runner.ts
 import { EventEmitter } from "events";
-import { getStoreLattice as getStoreLattice10, modelLatticeManager as modelLatticeManager2 } from "@axiom-lattice/core";
-import { LatticeEvalProject } from "@axiom-lattice/agent-eval";
+import {
+  getStoreLattice as getStoreLattice10,
+  modelLatticeManager as modelLatticeManager2,
+  LatticeEvalProject
+} from "@axiom-lattice/core";
 import { v4 as uuidv43 } from "uuid";
 function mapLogs(logs) {
   return logs.map((l) => ({
@@ -5194,6 +5268,11 @@ var EvalRunner = class {
     const store = this.getEvalStore();
     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");
@@ -5210,7 +5289,7 @@ var EvalRunner = class {
           caseId: c.id,
           input: { message: c.inputMessage, files: c.inputFiles },
           steps: c.steps,
-          output: { type: c.outputType },
+          output: { type: "message_content" },
           eval: {
             content_assertion: c.contentAssertion,
             eval_rubrics: c.rubrics?.map((r) => ({
@@ -5222,35 +5301,32 @@ var EvalRunner = class {
         }))
       });
     }
-    const runId = uuidv43();
-    const concurrency = project.concurrency || 3;
-    await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
-    const judgeCfg = project.judgeModelConfig;
-    const hasModelKey = Boolean(judgeCfg.modelKey);
-    const hasApiKey = Boolean(judgeCfg.apiKeyEnvName || judgeCfg.apiKey);
-    const hasCredentials = hasApiKey;
-    let judgeModelConfig = {};
-    if (hasModelKey) {
-      judgeModelConfig = { modelKey: judgeCfg.modelKey };
-    } else if (!hasCredentials) {
-      const firstModel = modelLatticeManager2.getAllLattices()[0];
-      if (firstModel) {
-        judgeModelConfig = { modelKey: firstModel.key };
-      } else {
-        judgeModelConfig = { model: judgeCfg };
+    const judgeCfg = project.judgeModelConfig ?? {};
+    const judgeModelKey = judgeCfg.modelKey || "";
+    let resolvedJudgeModelKey;
+    if (judgeModelKey) {
+      if (!modelLatticeManager2.hasLattice(judgeModelKey)) {
+        throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
+      resolvedJudgeModelKey = judgeModelKey;
     } else {
-      judgeModelConfig = { model: judgeCfg };
+      const firstModel = modelLatticeManager2.getAllLattices()[0];
+      if (!firstModel) {
+        throw new Error("No model registered \u2014 cannot run eval without a judge model");
+      }
+      resolvedJudgeModelKey = firstModel.key;
+      console.warn(`[eval-runner] Project "${project.name}" has no judge modelKey \u2014 falling back to first registered model "${firstModel.key}"`);
     }
+    const runId = uuidv43();
+    const concurrency = Math.max(1, Math.floor(project.concurrency) || 3);
+    await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
     const projectConfig = {
       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.base_url || "",
-        api_key: project.targetServerConfig.api_key || "",
         tenant_id: tenantId
       },
       concurrency
@@ -5295,33 +5371,37 @@ var EvalRunner = class {
     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: /* @__PURE__ */ 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 }
-        });
+        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: /* @__PURE__ */ 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 }
+          });
+        }
         return { report };
       } catch (err) {
         const errorMsg = err.message;
-        await store.updateRunStatus(tenantId, runId, {
-          status: "failed",
-          error: errorMsg,
-          completedAt: /* @__PURE__ */ new Date()
-        });
-        this.eventEmitter.emit(`run:${runId}`, {
-          type: "error",
-          runId,
-          data: { message: errorMsg }
-        });
+        if (!abortController.signal.aborted) {
+          await store.updateRunStatus(tenantId, runId, {
+            status: "failed",
+            error: errorMsg,
+            completedAt: /* @__PURE__ */ new Date()
+          });
+          this.eventEmitter.emit(`run:${runId}`, {
+            type: "error",
+            runId,
+            data: { message: errorMsg }
+          });
+        }
         throw err;
       } finally {
         this.runs.delete(runId);
@@ -5366,12 +5446,27 @@ async function createProject(request, reply) {
     const store = getEvalStore();
     const id = uuidv44();
     const data = request.body;
+    const serverCfg = data.targetServerConfig || {};
+    const judgeCfg = data.judgeModelConfig || {};
+    const modelKey = judgeCfg.modelKey || "";
+    if (modelKey) {
+      const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
+      if (!modelLatticeManager3.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 || ""
+      },
+      targetServerConfig: {
+        base_url: serverCfg.base_url || "",
+        api_key: serverCfg.api_key || ""
+      },
       concurrency: data.concurrency ?? 1,
       reportConfig: data.reportConfig
     });
@@ -5395,7 +5490,7 @@ async function listProjects(request, reply) {
         const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
         const models = modelLatticeManager3.getAllLattices();
         const first = models[0];
-        const judgeModel = first ? { modelKey: first.key } : { provider: "openai", model: "gpt-4" };
+        const judgeModel = first ? { modelKey: first.key } : {};
         const host = request.hostname || "localhost";
         const baseUrl = `http://${host}:${process.env.PORT || 4001}`;
         await store.createProject(tenantId, uuidv44(), {
@@ -5448,7 +5543,30 @@ async function updateProject(request, reply) {
     if (!existing) {
       return reply.status(404).send({ success: false, message: "Project not found" });
     }
-    const updated = await store.updateProject(tenantId, pid, request.body);
+    const body = request.body;
+    const updateData = { ...body };
+    const serverCfg = body.targetServerConfig || {};
+    if (body.targetServerConfig !== void 0) {
+      updateData.targetServerConfig = {
+        base_url: serverCfg.base_url || "",
+        api_key: serverCfg.api_key || ""
+      };
+    }
+    if (body.judgeModelConfig !== void 0) {
+      const judgeCfg = body.judgeModelConfig || {};
+      const modelKey = judgeCfg.modelKey || "";
+      if (modelKey) {
+        const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
+        if (!modelLatticeManager3.hasLattice(modelKey)) {
+          return reply.status(400).send({ success: false, message: `Judge model "${modelKey}" is not registered` });
+        }
+      }
+      updateData.judgeModelConfig = {
+        modelKey,
+        displayName: judgeCfg.displayName || ""
+      };
+    }
+    const updated = await store.updateProject(tenantId, pid, updateData);
     return {
       success: true,
       message: "Successfully updated project",
@@ -7499,6 +7617,7 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   app2.delete("/api/workflows/runs/:runId", deleteWorkflowRun);
   app2.get("/api/workflows/runs/:runId/steps", getRunSteps);
   app2.get("/api/workflows/runs/:runId/tasks", getRunTasks);
+  app2.post("/api/workflows/runs/:runId/abort", abortWorkflowRun);
   app2.post("/api/workflows/inbox/reply", replyInboxTask);
   app2.delete(
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
@@ -8018,7 +8137,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-import { setBindingRegistry, setMenuRegistry } from "@axiom-lattice/core";
+import { setBindingRegistry, setMenuRegistry, setEvalRunService } from "@axiom-lattice/core";
 
 // src/swagger.ts
 import swagger from "@fastify/swagger";
@@ -8573,6 +8692,7 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
+    setEvalRunService(evalRunner);
     try {
       const menuStore = getStoreLattice16("default", "menu").store;
       setMenuRegistry(menuStore);
@@ -8633,11 +8753,13 @@ var start = async (config) => {
         agentTaskConsumer.startPollingQueue();
       }
     }
-    agentInstanceManager8.restore().then((stats) => {
-      logger4.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-    }).catch((error) => {
-      logger4.error("Agent recovery failed", { error });
-    });
+    if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
+      agentInstanceManager8.restore().then((stats) => {
+        logger4.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
+      }).catch((error) => {
+        logger4.error("Agent recovery failed", { error });
+      });
+    }
     restoreMcpConnections().catch((error) => {
       logger4.error("MCP connection restoration failed", { error });
     });