@axiom-lattice/gateway 2.1.63 → 2.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.63",
+  "version": "2.1.64",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -39,8 +39,8 @@
     "pg": "^8.11.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.57",
-    "@axiom-lattice/pg-stores": "1.0.47",
+    "@axiom-lattice/core": "2.1.58",
+    "@axiom-lattice/pg-stores": "1.0.48",
     "@axiom-lattice/protocols": "2.1.30",
     "@axiom-lattice/queue-redis": "1.0.29"
   },

package/src/controllers/workflow-tracking.ts

@@ -0,0 +1,385 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice, agentInstanceManager } from "@axiom-lattice/core";
+import type { WorkflowTrackingStore, WorkflowRun, RunStep } from "@axiom-lattice/protocols";
+
+function getTenantId(request: FastifyRequest): string {
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+function getTrackingStore(): WorkflowTrackingStore | null {
+  try {
+    const storeLattice = getStoreLattice("default", "workflowTracking");
+    return storeLattice.store;
+  } catch {
+    return null;
+  }
+}
+
+interface ApiResponse<T = any> {
+  success: boolean;
+  message: string;
+  data?: T;
+}
+
+async function getDefinitionsFromAssistants(tenantId: string): Promise<Array<{
+  assistantId: string;
+  assistantName: string;
+  topologyEdges: { from: string; to: string; purpose: string }[];
+  totalEdges: number;
+}>> {
+  try {
+    const storeLattice = getStoreLattice("default", "assistant");
+    const assistantStore = storeLattice.store;
+    const assistants = await assistantStore.getAllAssistants(tenantId);
+
+    const results: Array<{
+      assistantId: string;
+      assistantName: string;
+      topologyEdges: { from: string; to: string; purpose: string }[];
+      totalEdges: number;
+    }> = [];
+
+    for (const a of assistants) {
+      const def = a.graphDefinition;
+      if (!def || def.type !== "processing") continue;
+      if (!def.middleware) continue;
+      for (const mw of def.middleware) {
+        if (mw.type === "topology" && mw.enabled && mw.config?.edges?.length > 0) {
+          results.push({
+            assistantId: a.id,
+            assistantName: a.name,
+            topologyEdges: mw.config.edges,
+            totalEdges: mw.config.edges.length,
+          });
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+export async function getAllWorkflowDefinitions(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: any[] }>> {
+  const tenantId = getTenantId(request);
+
+  try {
+    // Get definitions from assistant configs (always available, even before first run)
+    const configDefs = await getDefinitionsFromAssistants(tenantId);
+
+    if (configDefs.length === 0) {
+      return {
+        success: true,
+        message: "No workflow definitions found",
+        data: { records: [] },
+      };
+    }
+
+    // Merge in run-derived data (lastRunAt, runCount) if tracking store exists
+    const runMap = new Map<string, { lastRunAt?: string; runCount: number }>();
+    try {
+      const store = getTrackingStore();
+      if (store) {
+        const runs = await store.getWorkflowRunsByTenantId(tenantId);
+        for (const r of runs) {
+          const entry = runMap.get(r.assistantId) || { runCount: 0 };
+          entry.runCount++;
+          if (!entry.lastRunAt || new Date(r.startedAt) > new Date(entry.lastRunAt)) {
+            entry.lastRunAt = r.startedAt instanceof Date ? r.startedAt.toISOString() : String(r.startedAt);
+          }
+          runMap.set(r.assistantId, entry);
+        }
+      }
+    } catch {
+      // tracking store unavailable, definitions from config only
+    }
+
+    const definitions = configDefs.map((d) => {
+      const runInfo = runMap.get(d.assistantId);
+      return {
+        ...d,
+        lastRunAt: runInfo?.lastRunAt || null,
+        runCount: runInfo?.runCount || 0,
+      };
+    });
+
+    return {
+      success: true,
+      message: "Successfully retrieved workflow definitions",
+      data: { records: definitions },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow definitions");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow definitions" });
+  }
+}
+
+export async function getAllWorkflowRuns(
+  request: FastifyRequest<{ Querystring: { assistantId?: string; status?: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: WorkflowRun[]; total: number }>> {
+  const tenantId = getTenantId(request);
+  const { assistantId, status } = request.query;
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+
+    let runs: WorkflowRun[];
+    if (assistantId) {
+      runs = await store.getWorkflowRunsByAssistantId(tenantId, assistantId);
+    } else {
+      runs = await store.getWorkflowRunsByTenantId(tenantId);
+    }
+
+    if (status) {
+      runs = runs.filter(r => r.status === status);
+    }
+
+    return {
+      success: true,
+      message: "Successfully retrieved workflow runs",
+      data: { records: runs, total: runs.length },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow runs");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow runs" });
+  }
+}
+
+// GET /api/workflows/inbox
+export async function getInboxItems(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: any[] }>> {
+  const tenantId = getTenantId(request);
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return { success: true, message: "No tracking store configured", data: { records: [] } };
+    }
+
+    // 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
+    }
+
+    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 inboxItems: any[] = [];
+    for (const r of runningRuns) {
+      try {
+        const agent = agentInstanceManager.getAgent({
+          assistant_id: r.assistantId,
+          thread_id: r.threadId,
+          tenant_id: r.tenantId,
+        });
+        const runStatus = await agent.getRunStatus();
+
+        if (runStatus !== "interrupted") continue;
+
+        const state = await agent.getCurrentState();
+        const interrupts = state.tasks
+          ?.flatMap((t: any) => t.interrupts || []) || [];
+
+        for (const i of interrupts) {
+          inboxItems.push({
+            runId: r.id,
+            assistantId: r.assistantId,
+            assistantName: nameMap[r.assistantId] || r.assistantId,
+            threadId: r.threadId,
+            tenantId: r.tenantId,
+            interruptId: i.id,
+            interruptValue: i.value,
+            startedAt: r.startedAt,
+            totalEdges: r.totalEdges,
+            completedEdges: r.completedEdges,
+          });
+        }
+      } catch {
+        // agent unavailable, skip
+      }
+    }
+
+    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 },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get inbox items");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve inbox items" });
+  }
+}
+
+export async function getWorkflowDefinitions(
+  request: FastifyRequest<{ Params: { assistantId: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: any[] }>> {
+  const { assistantId } = request.params;
+  const tenantId = getTenantId(request);
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+
+    const runs = await store.getWorkflowRunsByAssistantId(tenantId, assistantId);
+    const seen = new Set<string>();
+    const definitions = runs
+      .filter(r => {
+        const key = JSON.stringify(r.topologyEdges);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      })
+      .map(r => ({
+        assistantId: r.assistantId,
+        topologyEdges: r.topologyEdges,
+        totalEdges: r.totalEdges,
+        lastRunAt: r.startedAt,
+      }));
+
+    return {
+      success: true,
+      message: "Successfully retrieved workflow definitions",
+      data: { records: definitions },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow definitions");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow definitions" });
+  }
+}
+
+export async function getWorkflowRuns(
+  request: FastifyRequest<{ Params: { assistantId: string; threadId: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: WorkflowRun[]; total: number }>> {
+  const { threadId } = request.params;
+  const tenantId = getTenantId(request);
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+
+    const runs = await store.getWorkflowRunsByThreadId(tenantId, threadId);
+    return {
+      success: true,
+      message: "Successfully retrieved workflow runs",
+      data: { records: runs, total: runs.length },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow runs");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow runs" });
+  }
+}
+
+export async function getWorkflowRun(
+  request: FastifyRequest<{ Params: { runId: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<WorkflowRun>> {
+  const { runId } = request.params;
+
+  try {
+    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" });
+    }
+
+    return { success: true, message: "Successfully retrieved workflow run", data: run };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow run");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow run" });
+  }
+}
+
+export async function getRunSteps(
+  request: FastifyRequest<{ Params: { runId: string }; Querystring: { step_type?: string; status?: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: RunStep[]; total: number }>> {
+  const { runId } = request.params;
+  const { step_type, status: stepStatus } = request.query;
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+
+    let steps: RunStep[];
+    if (step_type) {
+      steps = await store.getRunStepsByType(runId, step_type as any);
+    } else {
+      steps = await store.getRunSteps(runId);
+    }
+
+    if (stepStatus) {
+      steps = steps.filter(s => s.status === stepStatus);
+    }
+
+    return {
+      success: true,
+      message: "Successfully retrieved run steps",
+      data: { records: steps, total: steps.length },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get run steps");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve run steps" });
+  }
+}
+
+export async function getRunTasks(
+  request: FastifyRequest<{ Params: { runId: string } }>,
+  reply: FastifyReply
+): Promise<ApiResponse<{ records: RunStep[]; total: number }>> {
+  const { runId } = request.params;
+
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+
+    const steps = await store.getInterruptedSteps(runId);
+    return {
+      success: true,
+      message: "Successfully retrieved user tasks",
+      data: { records: steps, total: steps.length },
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get run tasks");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve user tasks" });
+  }
+}

package/src/index.ts

@@ -20,6 +20,7 @@ import {
   sandboxLatticeManager,
   sqlDatabaseManager,
   getStoreLattice,
+  storeLatticeManager,
   agentInstanceManager,
   createSandboxProvider,
   type CreateSandboxProviderConfig,
@@ -273,6 +274,23 @@ const start = async (config?: LatticeGatewayConfig) => {
       logger.info("Registered sandbox manager from env configuration");
     }
 
+    // Swap workflow tracking to PostgreSQL if DATABASE_URL is set
+    if (process.env.DATABASE_URL) {
+      try {
+        const { PostgreSQLWorkflowTrackingStore } = await import("@axiom-lattice/pg-stores");
+        const pgStore = new PostgreSQLWorkflowTrackingStore({
+          poolConfig: process.env.DATABASE_URL,
+        });
+        if (storeLatticeManager.hasLattice("default", "workflowTracking")) {
+          storeLatticeManager.removeLattice("default", "workflowTracking");
+        }
+        storeLatticeManager.registerLattice("default", "workflowTracking", pgStore);
+        logger.info("Workflow tracking store switched to PostgreSQL");
+      } catch (error) {
+        logger.warn("Failed to switch workflow tracking to PostgreSQL, keeping in-memory: " + (error instanceof Error ? error.message : String(error)));
+      }
+    }
+
     const target_port = config?.port || Number(process.env.PORT) || 4001;
 
     await app.listen({ port: target_port, host: "0.0.0.0" });

package/src/routes/index.ts

@@ -13,6 +13,7 @@ import * as healthController from "../controllers/health";
 import * as skillsController from "../controllers/skills";
 import * as toolsController from "../controllers/tools";
 import * as dataQueryController from "../controllers/data-query";
+import * as workflowTrackingController from "../controllers/workflow-tracking";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -349,6 +350,51 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
 
   registerChannelInstallationRoutes(app);
 
+  // Workflow tracking routes
+  app.get(
+    "/api/workflows/definitions",
+    workflowTrackingController.getAllWorkflowDefinitions
+  );
+
+  app.get<{
+    Querystring: { assistantId?: string; status?: string };
+  }>(
+    "/api/workflows/runs",
+    workflowTrackingController.getAllWorkflowRuns
+  );
+
+  app.get(
+    "/api/workflows/inbox",
+    workflowTrackingController.getInboxItems
+  );
+
+  app.get<{
+    Params: { assistantId: string };
+  }>(
+    "/api/assistants/:assistantId/workflows/definitions",
+    workflowTrackingController.getWorkflowDefinitions
+  );
+
+  app.get<{
+    Params: { assistantId: string; threadId: string };
+  }>(
+    "/api/assistants/:assistantId/threads/:threadId/workflows/runs",
+    workflowTrackingController.getWorkflowRuns
+  );
+
+  app.get<{
+    Params: { runId: string };
+  }>("/api/workflows/runs/:runId", workflowTrackingController.getWorkflowRun);
+
+  app.get<{
+    Params: { runId: string };
+    Querystring: { step_type?: string; status?: string };
+  }>("/api/workflows/runs/:runId/steps", workflowTrackingController.getRunSteps);
+
+  app.get<{
+    Params: { runId: string };
+  }>("/api/workflows/runs/:runId/tasks", workflowTrackingController.getRunTasks);
+
   // // Thread 状态查询路由
   // app.get("/api/threads/:thread_id/status", getThreadStatusHandler);
   // app.get("/api/assistants/:assistant_id/threads/status", getAgentThreadsHandler);

package/src/services/agent_task_consumer.ts

@@ -8,8 +8,11 @@ export interface AgentTaskRequest {
   thread_id: string;
   "x-tenant-id": string;
   command?: any;
-  callback_event?: string; // 可选的回调事件名称
-  runConfig?: Record<string, any>; // RunConfig for subagent execution
+  callback_event?: string;
+  runConfig?: Record<string, any>;
+  main_thread_id?: string;
+  main_tenant_id?: string;
+  main_assistant_id?: string;
 }
 
 /**
@@ -29,6 +32,9 @@ const handleAgentTask = async (
     command,
     callback_event,
     runConfig,
+    main_thread_id,
+    main_tenant_id,
+    main_assistant_id,
   } = taskRequest;
 
 
@@ -50,6 +56,38 @@ const handleAgentTask = async (
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id },
         });
+
+        if (main_thread_id && main_tenant_id) {
+          try {
+            const mainAgent = agentInstanceManager.getAgent({
+              assistant_id: main_assistant_id ?? assistant_id,
+              thread_id: main_thread_id,
+              tenant_id: main_tenant_id,
+            });
+            if (mainAgent) {
+              const messages = evt.state?.values?.messages;
+              const lastAIMessage = messages
+                ?.filter((m: any) => m.type === 'ai' || m.getType?.() === 'ai')
+                .pop();
+              const summary = lastAIMessage?.content
+                ?.substring(0, 500) ?? '(no output)';
+
+              mainAgent.addMessage(
+                {
+                  input: {
+                    message: `[Async task completed]\ntask_id: ${thread_id}\n${summary}`,
+                  },
+                },
+              ).catch((err: Error) => {
+                console.error('Failed to notify main thread:', err);
+              });
+
+              mainAgent.updateAsyncTaskStatus(thread_id, 'completed');
+            }
+          } catch (err) {
+            console.error('Failed to notify main thread:', err);
+          }
+        }
       })
       agent.subscribeOnce("message:interrupted", (evt) => {
         eventBus.publish(callback_event, {