@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/workflow-tracking.ts

@@ -1,693 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-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";
-
-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;
-  description?: 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;
-      description?: 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) {
-          results.push({
-            assistantId: a.id,
-            assistantName: a.name,
-            description: a.description,
-            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: any[]; 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" });
-    }
-
-    // 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);
-    } else {
-      runs = await store.getWorkflowRunsByTenantId(tenantId);
-    }
-
-    if (status) {
-      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: enrichedRuns, total: enrichedRuns.length },
-    };
-  } catch (error) {
-    request.log.error({ tenantId, assistantId, status, error: (error as Error).stack || (error as Error).message }, "Failed to get workflow runs");
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve workflow runs: ${(error as Error).message}`,
-    });
-  }
-}
-
-// 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<{ Querystring: { page?: string; pageSize?: string } }>,
-  reply: FastifyReply
-): Promise<ApiResponse<{ records: any[]; total?: number; page?: number; pageSize?: number }>> {
-  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 { 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: paged ? { records: [], total, page, pageSize } : { records: [] },
-      };
-    }
-
-    // Parallelize agent checks across interrupted workflows
-    const checkPromises = pendingRuns.map(async (r) => {
-      try {
-        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 || []) || [];
-
-        return interrupts.map((i: any) => ({
-          runId: r.id,
-          assistantId: r.assistantId,
-          assistantName: nameMap[r.assistantId] || r.assistantId,
-          threadId: r.threadId,
-          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");
-        return [];
-      }
-    });
-
-    const results = await Promise.all(checkPromises);
-    const inboxItems = results.flat();
-    // 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: paged ? { records: inboxItems, total, page, pageSize } : { 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 deleteWorkflowRun(
-  request: FastifyRequest<{ Params: { runId: string } }>,
-  reply: FastifyReply
-): Promise<ApiResponse> {
-  const { runId } = 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 run = await store.getWorkflowRun(runId);
-    if (!run) {
-      return reply.status(404).send({ success: false, message: "Workflow run not found" });
-    }
-
-    // If run is still running, abort the agent first
-    if (run.status === "running") {
-      try {
-        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();
-      } catch (err) {
-        request.log.warn({ runId, error: (err as Error).message }, "Failed to abort agent, deleting tracking records anyway");
-      }
-    }
-
-    await store.deleteWorkflowRun(runId);
-
-    return { success: true, message: "Workflow run deleted" };
-  } catch (error) {
-    request.log.error(error, "Failed to delete workflow run");
-    return reply.status(500).send({ success: false, message: "Failed to delete 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({ runId, error: (error as Error).stack || (error as Error).message }, "Failed to get run steps");
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve run steps: ${(error as Error).message}`,
-    });
-  }
-}
-
-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" });
-  }
-}
-
-// 简化的 Inbox 任务回复接口
-interface ReplyInboxRequest {
-  runId: string;
-  answers: Array<{
-    questionIndex: number;
-    selectedOptions: string[];
-  }>;
-}
-
-export async function replyInboxTask(
-  request: FastifyRequest<{ Body: ReplyInboxRequest }>,
-  reply: FastifyReply
-): Promise<void> {
-  const { runId, answers } = request.body;
-  const tenantId = getTenantId(request);
-
-  try {
-    // 1. 获取 WorkflowRun 信息
-    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" 
-      });
-    }
-
-    // 2. 获取 Agent 实例（补齐参数，与 createRun 一致）
-    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,
-    });
-
-    // 3. 检查 graph 是否处于中断状态
-    const runStatus = await agent.getRunStatus();
-    if (runStatus !== ThreadStatus.INTERRUPTED) {
-      return reply.status(409).send({
-        success: false,
-        message: `Cannot resume: graph is not interrupted (current status: ${runStatus})`,
-        data: { runId: run.id, assistantId: run.assistantId, threadId: run.threadId, status: runStatus },
-      });
-    }
-
-    // 4. 直接在后台触发 resume 执行（不等待，不阻塞 HTTP 响应）
-    agent.addMessage({
-      input: { message: "Clarification answers submitted" },
-      command: {
-        resume: {
-          action: "submit",
-          data: { answers },
-          message: "Clarification answers submitted",
-        },
-      },
-    }).then((result) => {
-      // addMessage 成功后，触发 chunkStream 消费（驱动执行）
-      // 不 await stream，让它在后台运行
-      const stream = agent.chunkStream(
-        result.messageId, 
-        [MessageChunkTypes.MESSAGE_COMPLETED]
-      );
-      // 消费 stream 但不阻塞（后台驱动 agent 执行）
-      (async () => {
-        for await (const _ of stream) { /* 丢弃 chunks */ }
-      })().catch((error) => {
-        request.log.error(error, "Background chunk stream error");
-      });
-    }).catch((error) => {
-      request.log.error(error, "Background resume failed");
-    });
-
-    // 5. 立即返回成功（不等待 agent 执行完成）
-    return reply.status(200).send({
-      success: true,
-      message: "Resume request submitted successfully",
-      data: {
-        runId: run.id,
-        assistantId: run.assistantId,
-        threadId: run.threadId,
-        status: "resuming",
-      },
-    });
-
-  } catch (error) {
-    request.log.error(error, "Failed to reply inbox task");
-    return reply.status(500).send({ 
-      success: false, 
-      message: "Failed to submit resume request" 
-    });
-  }
-}
-
-/**
- * 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}`,
-    });
-  }
-}