@axiom-lattice/gateway 2.1.90 → 2.1.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.90",
+  "version": "2.1.92",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -40,11 +40,11 @@
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
     "zod": "3.25.76",
-    "@axiom-lattice/agent-eval": "2.1.72",
-    "@axiom-lattice/core": "2.1.78",
-    "@axiom-lattice/pg-stores": "1.0.69",
-    "@axiom-lattice/protocols": "2.1.40",
-    "@axiom-lattice/queue-redis": "1.0.39"
+    "@axiom-lattice/agent-eval": "2.1.74",
+    "@axiom-lattice/core": "2.1.80",
+    "@axiom-lattice/pg-stores": "1.0.71",
+    "@axiom-lattice/protocols": "2.1.42",
+    "@axiom-lattice/queue-redis": "1.0.41"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/controllers/workflow-tracking.ts

@@ -126,7 +126,7 @@ export async function getAllWorkflowDefinitions(
 export async function getAllWorkflowRuns(
   request: FastifyRequest<{ Querystring: { assistantId?: string; status?: string } }>,
   reply: FastifyReply
-): Promise<ApiResponse<{ records: WorkflowRun[]; total: number }>> {
+): Promise<ApiResponse<{ records: any[]; total: number }>> {
   const tenantId = getTenantId(request);
   const { assistantId, status } = request.query;
 
@@ -136,6 +136,19 @@ export async function getAllWorkflowRuns(
       return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
     }
 
+    // Resolve assistant names
+    const nameMap: Record<string, string> = {};
+    try {
+      const asStoreLattice = getStoreLattice("default", "assistant");
+      const assistantStore = asStoreLattice.store;
+      const assistants = await assistantStore.getAllAssistants(tenantId);
+      for (const a of assistants) {
+        nameMap[a.id] = a.name;
+      }
+    } catch {
+      // names unavailable, will fall back to ID
+    }
+
     let runs: WorkflowRun[];
     if (assistantId) {
       runs = await store.getWorkflowRunsByAssistantId(tenantId, assistantId);
@@ -147,10 +160,24 @@ export async function getAllWorkflowRuns(
       runs = runs.filter(r => r.status === status);
     }
 
+    // Enrich runs with step counts (more accurate than edge-based counts for branching workflows)
+    const enrichedRuns = await Promise.all(
+      runs.map(async (run) => {
+        try {
+          const steps = await store.getRunSteps(run.id);
+          const totalSteps = steps.length;
+          const completedSteps = steps.filter(s => s.status === 'completed').length;
+          return { ...run, totalSteps, completedSteps, assistantName: nameMap[run.assistantId] || run.assistantId };
+        } catch {
+          return { ...run, totalSteps: 0, completedSteps: 0, assistantName: nameMap[run.assistantId] || run.assistantId };
+        }
+      })
+    );
+
     return {
       success: true,
       message: "Successfully retrieved workflow runs",
-      data: { records: runs, total: runs.length },
+      data: { records: enrichedRuns, total: enrichedRuns.length },
     };
   } catch (error) {
     request.log.error(error, "Failed to get workflow runs");
@@ -185,25 +212,49 @@ export async function getInboxItems(
     }
 
     const runs = await store.getWorkflowRunsByTenantId(tenantId);
-    const runningRuns = runs.filter(r => r.status === "running");
-    if (runningRuns.length === 0) {
-      return { success: true, message: "No running workflows", data: { records: [] } };
+    const pendingRuns = runs.filter(r => r.status === "interrupted");
+    if (pendingRuns.length === 0) {
+      return { success: true, message: "No pending workflows", data: { records: [] } };
     }
 
-    // Parallelize agent checks across running workflows
-    const checkPromises = runningRuns.map(async (r) => {
+    // Parallelize agent checks across interrupted workflows
+    const checkPromises = pendingRuns.map(async (r) => {
       try {
-        const agent = agentInstanceManager.getAgent({
-          assistant_id: r.assistantId,
-          thread_id: r.threadId,
-          tenant_id: r.tenantId,
-        });
+        const [steps, agent] = await Promise.all([
+          store.getRunSteps(r.id).catch(() => []),
+          (async () => {
+            try {
+              return agentInstanceManager.getAgent({
+                assistant_id: r.assistantId,
+                thread_id: r.threadId,
+                tenant_id: r.tenantId,
+              });
+            } catch {
+              return null;
+            }
+          })(),
+        ]);
+
+        if (!agent) {
+          // Agent not available — still return raw item so UI knows a human step exists
+          return [{
+            runId: r.id,
+            assistantId: r.assistantId,
+            assistantName: nameMap[r.assistantId] || r.assistantId,
+            threadId: r.threadId,
+            tenantId: r.tenantId,
+            status: r.status,
+            startedAt: r.startedAt,
+            totalEdges: r.totalEdges,
+            completedEdges: r.completedEdges,
+            steps,
+          }];
+        }
 
         const runStatus = await agent.getRunStatus();
         if (runStatus !== "interrupted") return [];
 
         const state = await agent.getCurrentState();
-
         const interrupts = state.tasks
           ?.flatMap((t: any) => t.interrupts || []) || [];
 
@@ -215,9 +266,11 @@ export async function getInboxItems(
           tenantId: r.tenantId,
           interruptId: i.id,
           interruptValue: i.value,
+          status: r.status,
           startedAt: r.startedAt,
           totalEdges: r.totalEdges,
           completedEdges: r.completedEdges,
+          steps,
         }));
       } catch (err) {
         request.log.warn({ runId: r.id, error: (err as Error).message }, "Agent check skipped");