@axiom-lattice/gateway 2.1.91 → 2.1.93

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");

package/src/index.ts

@@ -11,7 +11,7 @@ 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 } from "@axiom-lattice/core";
+import { setBindingRegistry, setMenuRegistry } from "@axiom-lattice/core";
 import { larkChannelAdapter } from "./channels/lark/LarkChannelAdapter";
 import { extractUserFromAuthHeader } from "./controllers/auth";
 import { configureSwagger } from "./swagger";
@@ -277,17 +277,22 @@ const start = async (config?: LatticeGatewayConfig) => {
     // Access via: request.server.loggerLattice or app.loggerLattice
     app.decorate("loggerLattice", loggerLattice);
 
-    // Channel infrastructure: use stores from StoreLatticeManager (defaults: InMemory).
-    // Projects can override with PG stores via registerStoreLattice before start().
+    // Channel infrastructure: use stores from StoreLatticeManager.
+    // Applications (e.g. deep_research) register stores via configureStores()
+    // before calling startAsHttpEndpoint(). If no stores are registered,
+    // channel features are gracefully skipped.
     let channelDeps: { router: MessageRouter; installationStore: ChannelInstallationStore } | undefined;
+    const adapterRegistry = new ChannelAdapterRegistry();
+    adapterRegistry.register(larkChannelAdapter);
     try {
-      const { getStoreLattice } = await import("@axiom-lattice/core");
-      const bindingStore = getStoreLattice("default", "channelBinding").store as BindingRegistry;
-      const installationStore = getStoreLattice("default", "channelInstallation").store as ChannelInstallationStore;
-      setBindingRegistry(bindingStore);
+      const { getStoreLattice: getStore } = await import("@axiom-lattice/core");
+      let bindingStore: BindingRegistry;
+      let installationStore: ChannelInstallationStore;
+
+      bindingStore = getStore("default", "channelBinding").store as BindingRegistry;
+      installationStore = getStore("default", "channelInstallation").store as ChannelInstallationStore;
 
-      const adapterRegistry = new ChannelAdapterRegistry();
-      adapterRegistry.register(larkChannelAdapter);
+      setBindingRegistry(bindingStore);
 
       const router = new MessageRouter({
         middlewares: [
@@ -305,7 +310,7 @@ const start = async (config?: LatticeGatewayConfig) => {
 
       // Initialize A2A API key store
       try {
-        const a2aKeyStore = getStoreLattice("default", "a2aApiKey").store as import("@axiom-lattice/protocols").A2AApiKeyStore;
+        const a2aKeyStore = getStore("default", "a2aApiKey").store as import("@axiom-lattice/protocols").A2AApiKeyStore;
         const a2a = await import("./routes/a2a");
         a2a.setA2AKeyStore(a2aKeyStore);
         await a2a.refreshStoreKeyMap();
@@ -313,8 +318,19 @@ const start = async (config?: LatticeGatewayConfig) => {
       } catch {
         // A2A key store optional — env-based keys still work
       }
+    } catch (err) {
+      logger.warn("Channel infrastructure unavailable", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
+    // Initialize MenuRegistry for custom menu items
+    try {
+      const menuStore = getStoreLattice("default", "menu").store;
+      setMenuRegistry(menuStore);
+      logger.info("Menu registry initialized");
     } catch {
-      // Stores not registered — channel routes will be skipped gracefully
+      // Menu store optional — custom menus won't work without it
     }
 
     // Register all routes (channel routes only active if channelDeps is set)
@@ -326,6 +342,21 @@ const start = async (config?: LatticeGatewayConfig) => {
       logger.info("Registered sandbox manager from env configuration");
     }
 
+    // Connect all enabled channel installations
+    if (channelDeps && process.env.CHANNELS_ENABLED !== "false") {
+      const { connectAllChannels } = await import("@axiom-lattice/core");
+      try {
+        await connectAllChannels(
+          (channel) => adapterRegistry.get(channel),
+          { deps: { router: channelDeps.router } },
+        );
+      } catch (err) {
+        logger.error("Failed to start channel connections", {
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+
     const target_port = config?.port || Number(process.env.PORT) || 4001;
 
     await app.listen({ port: target_port, host: "0.0.0.0" });
@@ -348,15 +379,14 @@ const start = async (config?: LatticeGatewayConfig) => {
       }
     }
 
-    // Restore agent instances with pending messages
-    try {
-      logger.info("Starting agent instance recovery...");
-      const restoreStats = await agentInstanceManager.restore();
-      logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
-    } catch (error) {
-      logger.error("Agent recovery failed", { error });
-      // Don't exit - server can still function even if recovery fails
-    }
+    // 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 });
+      });
   } catch (err) {
     logger.error("Server start failed", { error: err });
     process.exit(1);

package/src/router/MessageRouter.ts

@@ -6,6 +6,7 @@ import type {
   InboundMessage,
   DispatchResult,
   BindingRegistry,
+  Binding,
   ChannelInstallationStore,
 } from "@axiom-lattice/protocols";
 import { ChannelAdapterRegistry } from "../channels/registry";
@@ -112,6 +113,10 @@ export class MessageRouter {
       metadata: {},
     };
 
+    let binding: Binding | null = null;
+    let threadId: string | undefined;
+    let agentId: string | undefined;
+
     try {
       await this.runMiddlewares(ctx, async () => {
         // Resolve tenantId from installation if not provided
@@ -133,18 +138,22 @@ export class MessageRouter {
 
         console.log({ event: "dispatch:start", channel: message.channel, senderId: message.sender.id, tenantId }, "Message dispatch started");
 
-        let binding = await this.bindingRegistry.resolve({
+        // 检查 adapter 是否支持自定义 thread 策略
+        const adapter = this.adapterRegistry.get(message.channel);
+        const hasAdapterThreadStrategy = !!adapter?.resolveThreadId;
+
+        binding = await this.bindingRegistry.resolve({
           channel: message.channel,
           senderId: message.sender.id,
           channelInstallationId: message.channelInstallationId,
           tenantId,
         });
 
-        if (!binding) {
-          const installation = await this.installationStore.getInstallationById(
-            message.channelInstallationId,
-          );
+        const installation = await this.installationStore.getInstallationById(
+          message.channelInstallationId,
+        );
 
+        if (!binding) {
           if (installation?.rejectWhenNoBinding) {
             console.warn({
               event: "dispatch:no_binding",
@@ -178,7 +187,8 @@ export class MessageRouter {
               createdAt: new Date(),
               updatedAt: new Date(),
             };
-          } else {
+          } else if (!hasAdapterThreadStrategy) {
+            // 只有当 adapter 没有自定义 thread 策略且没有 fallback 时才报错
             console.error({
               event: "dispatch:no_fallback",
               channel: message.channel,
@@ -191,53 +201,110 @@ export class MessageRouter {
           }
         }
 
-        ctx.binding = binding;
+        ctx.binding = binding ?? undefined;
 
-        console.log({
-          event: "dispatch:binding",
-          bindingId: binding.id,
-          agentId: binding.agentId,
-          threadId: binding.threadId,
-          threadMode: binding.threadMode,
-          workspaceId: binding.workspaceId,
-          projectId: binding.projectId,
-        }, "Binding resolved");
-
-        if (!binding.enabled) {
-          console.warn({
-            event: "dispatch:binding_disabled",
+        if (binding) {
+          console.log({
+            event: "dispatch:binding",
             bindingId: binding.id,
             agentId: binding.agentId,
-            senderId: message.sender.id,
-          }, "Binding is disabled, rejecting message");
+            threadId: binding.threadId,
+            threadMode: binding.threadMode,
+            workspaceId: binding.workspaceId,
+            projectId: binding.projectId,
+          }, "Binding resolved");
+
+          if (!binding.enabled) {
+            console.warn({
+              event: "dispatch:binding_disabled",
+              bindingId: binding.id,
+              agentId: binding.agentId,
+              senderId: message.sender.id,
+            }, "Binding is disabled, rejecting message");
+            throw new BindingNotFoundError(
+              `Binding for sender "${message.sender.id}" is disabled`,
+            );
+          }
+        }
+
+        // 确定 agentId
+        agentId = binding?.agentId ?? installation?.fallbackAgentId;
+        if (!agentId) {
           throw new BindingNotFoundError(
-            `Binding for sender "${message.sender.id}" is disabled`,
+            `No agent configured for sender "${message.sender.id}"`,
           );
         }
 
-        let threadId: string | undefined = ctx.binding.threadMode === "per_conversation"
-          ? undefined // always create new thread for per_conversation
-          : ctx.binding.threadId;
+        // 优先使用 adapter 的自定义 thread 策略
+        if (hasAdapterThreadStrategy) {
+          const resolvedThreadId = await adapter!.resolveThreadId!(message, binding);
+          threadId = resolvedThreadId;
+          console.log({
+            event: "dispatch:thread:adapter",
+            threadId,
+            channel: message.channel,
+            adapterChannel: adapter!.channel,
+          }, "Thread resolved by adapter strategy");
+
+          // 确保 thread 存在（adapter 的策略可能有重复，例如同一天）
+          const threadStore = getStoreLattice("default", "thread").store;
+          try {
+            await threadStore.createThread(
+              tenantId!,
+              agentId,
+              threadId,
+              {
+                metadata: {
+                  channel: message.channel,
+                  channelInstallationId: message.channelInstallationId,
+                  senderId: message.sender.id,
+                  bindingId: binding?.id,
+                  ...(message.conversation ? {
+                    conversationId: message.conversation.id,
+                    conversationType: message.conversation.type,
+                  } : {}),
+                },
+              },
+            );
+            console.log({
+              event: "dispatch:thread:adapter:created",
+              threadId,
+            }, "Thread created by adapter strategy");
+          } catch {
+            // Thread already exists from a previous message — 复用
+            console.log({
+              event: "dispatch:thread:adapter:reuse",
+              threadId,
+            }, "Thread already exists, reusing");
+          }
+        } else if (binding) {
+          // 默认策略：per_conversation 总是创建新线程，fixed 复用已有线程
+          if (binding.threadMode === "per_conversation") {
+            threadId = undefined; // 创建新线程
+          } else {
+            threadId = binding.threadId; // 复用 fixed 线程
+          }
+        }
 
         if (!threadId) {
           const threadStore = getStoreLattice("default", "thread").store;
           const newThreadId = randomUUID();
           console.log({
             event: "dispatch:thread:create",
-            agentId: ctx.binding.agentId,
+            agentId,
             newThreadId,
             tenantId: tenantId!,
           }, "Creating new thread for binding");
           const newThread = await threadStore.createThread(
             tenantId!,
-            ctx.binding.agentId,
+            agentId,
             newThreadId,
             {
               metadata: {
                 channel: message.channel,
                 channelInstallationId: message.channelInstallationId,
                 senderId: message.sender.id,
-                bindingId: ctx.binding.id,
+                bindingId: binding?.id,
                 ...(message.conversation ? {
                   conversationId: message.conversation.id,
                   conversationType: message.conversation.type,
@@ -246,29 +313,28 @@ export class MessageRouter {
             },
           );
           threadId = newThread.id;
-          if (ctx.binding.id !== "fallback") {
-            await this.bindingRegistry.update(ctx.binding.id, { threadId });
-            ctx.binding.threadId = threadId;
-          } else {
-            ctx.binding.threadId = threadId;
+          if (binding && binding.id !== "fallback") {
+            await this.bindingRegistry.update(binding.id, { threadId });
+            binding.threadId = threadId;
+          } else if (binding) {
+            binding.threadId = threadId;
           }
         }
 
         console.log({
           event: "dispatch:agent",
-          agentId: ctx.binding.agentId,
+          agentId,
           threadId,
-          threadMode: ctx.binding.threadMode,
           senderId: message.sender.id,
           contentLength: message.content.text.length,
         }, "Dispatching to agent");
 
         const agent = agentInstanceManager.getAgent({
           tenant_id: tenantId!,
-          assistant_id: ctx.binding.agentId,
+          assistant_id: agentId,
           thread_id: threadId,
-          workspace_id: ctx.binding.workspaceId || "",
-          project_id: ctx.binding.projectId || "",
+          workspace_id: binding?.workspaceId || "",
+          project_id: binding?.projectId || "",
         });
 
         /**
@@ -383,7 +449,7 @@ export class MessageRouter {
 
         console.log({
           event: "dispatch:complete",
-          agentId: ctx.binding.agentId,
+          agentId,
           threadId,
           messageId: (addResult as Record<string, unknown>)?.messageId,
           result: JSON.stringify(addResult),
@@ -393,7 +459,7 @@ export class MessageRouter {
       return {
         success: true,
         bindingId: ctx.binding?.id,
-        threadId: ctx.binding?.threadId,
+        threadId,
         result: ctx.result,
       };
     } catch (error) {

package/src/routes/index.ts

@@ -14,6 +14,8 @@ 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 * as paController from "../controllers/personal-assistant";
+import * as tasksController from "../controllers/tasks";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -44,6 +46,7 @@ import { registerAuthRoutes } from "../controllers/auth";
 import { registerChannelRoutes } from "../channels/routes";
 import { registerChannelInstallationRoutes } from "./channel-installations";
 import { registerChannelBindingRoutes } from "./channel-bindings";
+import { registerMenuItemRoutes } from "./menu-items";
 import type { MessageRouter } from "../router/MessageRouter";
 import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
 // import {
@@ -76,6 +79,11 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     Params: { assistantId: string; threadId: string };
   }>("/api/assistants/:assistantId/threads/:threadId/abort", runController.abortRun);
 
+  // Recover agent execution after a crash or manual abort
+  app.post<{
+    Params: { assistantId: string; threadId: string };
+  }>("/api/assistants/:assistantId/threads/:threadId/recover", runController.recoverRun);
+
   // app.get<{
   //   Params: { id: string };
   // }>("/api/runs/:id", runController.getRun);
@@ -158,6 +166,19 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
     Params: { id: string };
   }>("/api/assistants/:id", assistantController.deleteAssistant);
 
+  // Personal Assistant routes
+  app.post<{ Body: any }>("/api/personal-assistant", paController.createPersonalAssistant);
+  app.get("/api/personal-assistant", paController.getPersonalAssistant);
+  app.delete("/api/personal-assistant", paController.deletePersonalAssistant);
+
+  // Task CRUD routes
+  app.get("/api/tasks", tasksController.listTasks);
+  app.get("/api/tasks/:id", tasksController.getTask);
+  app.post("/api/tasks", tasksController.createTask);
+  app.put("/api/tasks/:id", tasksController.updateTask);
+  app.delete("/api/tasks/:id", tasksController.deleteTask);
+  app.patch("/api/tasks/:id/complete", tasksController.completeTask);
+
   // 图表路由
   app.get<{
     Params: { assistantId: string };
@@ -361,6 +382,8 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
 
   registerChannelInstallationRoutes(app);
 
+  registerMenuItemRoutes(app);
+
   if (channelDeps) {
     registerChannelBindingRoutes(app);
   }

package/src/routes/menu-items.ts

@@ -0,0 +1,10 @@
+import type { FastifyInstance } from "fastify";
+import * as menuController from "../controllers/menu-items";
+
+export function registerMenuItemRoutes(app: FastifyInstance): void {
+  app.get("/api/menu-items", menuController.getMenuItemList);
+  app.post("/api/menu-items", menuController.createMenuItem);
+  app.get("/api/menu-items/:id", menuController.getMenuItem);
+  app.put("/api/menu-items/:id", menuController.updateMenuItem);
+  app.delete("/api/menu-items/:id", menuController.deleteMenuItem);
+}

package/src/services/agent_task_consumer.ts

@@ -54,7 +54,6 @@ const handleAgentTask = async (
         eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
-          config: { assistant_id, thread_id, tenant_id },
         });
 
         if (main_thread_id && main_tenant_id) {
@@ -63,6 +62,8 @@ const handleAgentTask = async (
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id,
+              workspace_id: runConfig?.workspaceId,
+              project_id: runConfig?.projectId,
             });
             if (mainAgent) {
               const messages = evt.state?.values?.messages;
@@ -93,7 +94,6 @@ const handleAgentTask = async (
         eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
-          config: { assistant_id, thread_id, tenant_id },
         });
       })
     }
@@ -127,7 +127,6 @@ const handleAgentTask = async (
       eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
-        config: { assistant_id, thread_id, tenant_id },
       });
     }
 
@@ -334,11 +333,6 @@ export class AgentTaskConsumer {
         eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
-          config: {
-            assistant_id: taskRequest.assistant_id,
-            thread_id: taskRequest.thread_id,
-            tenant_id: taskRequest["x-tenant-id"],
-          },
         });
       }
     });

package/src/channels/lark/__tests__/aggregator.test.ts

@@ -1,23 +0,0 @@
-import { MessageChunkTypes } from "@axiom-lattice/protocols";
-import { aggregateLarkReply } from "../aggregator";
-
-describe("aggregateLarkReply", () => {
-  it("joins ai chunks for the requested message id", () => {
-    const result = aggregateLarkReply("msg-1", [
-      { type: MessageChunkTypes.AI, data: { id: "msg-1", content: "Hel" } },
-      { type: MessageChunkTypes.AI, data: { id: "msg-2", content: "skip" } },
-      { type: MessageChunkTypes.TOOL, data: { id: "msg-1", content: "ignore" } },
-      { type: MessageChunkTypes.AI, data: { id: "msg-1", content: "lo" } },
-    ]);
-
-    expect(result).toBe("Hello");
-  });
-
-  it("returns an empty string when no ai content exists for the message", () => {
-    const result = aggregateLarkReply("msg-1", [
-      { type: MessageChunkTypes.MESSAGE_COMPLETED, data: { id: "msg-1" } },
-    ]);
-
-    expect(result).toBe("");
-  });
-});

package/src/channels/lark/aggregator.ts

@@ -1,16 +0,0 @@
-import type { MessageChunk } from "@axiom-lattice/protocols";
-import { MessageChunkTypes } from "@axiom-lattice/protocols";
-
-export function aggregateLarkReply(
-  messageId: string,
-  chunks: MessageChunk[],
-): string {
-  return chunks
-    .filter(
-      (chunk) =>
-        chunk.type === MessageChunkTypes.AI && chunk.data.id === messageId,
-    )
-    .map((chunk) => chunk.data.content || "")
-    .join("")
-    .trim();
-}