@lota-sdk/core 0.4.9 → 0.4.11

package/src/services/agent-activity.service.ts

@@ -9,9 +9,9 @@ import type {
 } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
-import { getAgentRoster } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
-import { toAwaitableEffect } from '../effect/awaitable-effect'
+import { AgentConfigServiceTag } from '../effect/services'
 import { unsafeDateFrom } from '../utils/date-time'
 import type { makeExecutionPlanService } from './execution-plan/execution-plan.service'
 import { ExecutionPlanServiceTag } from './execution-plan/execution-plan.service'
@@ -37,6 +37,7 @@ type ActivePlanEntry = {
 }
 
 type AgentActivityDeps = {
+  agentConfig: ResolvedAgentConfig
   executionPlanService: Pick<ReturnType<typeof makeExecutionPlanService>, 'getActivePlansForThread'>
   threadService: Pick<ReturnType<typeof makeThreadService>, 'listThreads'>
 }
@@ -154,158 +155,97 @@ function buildPlanViewNode(
 }
 
 export function getBoard(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const cards = activePlans
-        .filter(({ plan }) => !isPendingPlanApproval(plan))
-        .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
-
-      const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
-        status,
-        label: COLUMN_LABELS[status],
-        nodes: cards.filter((card) => card.status === status),
-      }))
-
-      return {
-        columns,
-        summary: {
-          totalNodes: cards.length,
-          completedNodes: cards.filter((card) => card.status === 'completed').length,
-          activePlanCount: activePlans.length,
-          pendingApprovalCount:
-            countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
-        },
-      }
-    }),
-  )
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const cards = activePlans
+      .filter(({ plan }) => !isPendingPlanApproval(plan))
+      .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
+
+    const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
+      status,
+      label: COLUMN_LABELS[status],
+      nodes: cards.filter((card) => card.status === status),
+    }))
+
+    return {
+      columns,
+      summary: {
+        totalNodes: cards.length,
+        completedNodes: cards.filter((card) => card.status === 'completed').length,
+        activePlanCount: activePlans.length,
+        pendingApprovalCount: countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
+      },
+    }
+  })
 }
 
 export function getPlanView(orgRef: string, planRunId: string, userRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const match = activePlans.find(({ plan }) => plan.runId === planRunId)
-      if (!match) return null
-
-      const { plan, thread } = match
-      return {
-        planRunId: plan.runId,
-        title: plan.title,
-        objective: plan.objective,
-        status: plan.status,
-        leadAgentId: plan.leadAgentId,
-        progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
-        nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
-        edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
-      }
-    }),
-  )
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const match = activePlans.find(({ plan }) => plan.runId === planRunId)
+    if (!match) return null
+
+    const { plan, thread } = match
+    return {
+      planRunId: plan.runId,
+      title: plan.title,
+      objective: plan.objective,
+      status: plan.status,
+      leadAgentId: plan.leadAgentId,
+      progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
+      nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
+      edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
+    }
+  })
 }
 
 export function getMyTasks(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const tasks: PlanNodeCard[] = []
-      const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
-
-      for (const { plan, thread } of activePlans) {
-        if (isPendingPlanApproval(plan)) {
-          continue
-        }
-
-        for (const node of plan.nodes) {
-          const humanOwned = node.owner.executorType === 'user'
-          const awaitingHuman = node.status === 'awaiting-human'
-          if (!humanOwned && !awaitingHuman) continue
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const tasks: PlanNodeCard[] = []
+    const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
 
-          tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
-        }
+    for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
+        continue
       }
 
-      return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
-    }),
-  )
-}
+      for (const node of plan.nodes) {
+        const humanOwned = node.owner.executorType === 'user'
+        const awaitingHuman = node.status === 'awaiting-human'
+        if (!humanOwned && !awaitingHuman) continue
 
-export function getAgentActivity(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const [activePlans, userTasks] = yield* Effect.all([
-        getAllActivePlans(userRef, orgRef, deps),
-        getMyTasks(userRef, orgRef, deps),
-      ])
-      const activityByAgent = new Map<string, AgentActivityEntry>()
-
-      const agentRoster = getAgentRoster()
-      for (const agentId of agentRoster) {
-        activityByAgent.set(agentId, {
-          agentId,
-          counts: createEmptyCounts(),
-          tasks: [],
-          projects: [],
-          isLeadingActivePlan: false,
-          isRunning: false,
-          lastActiveAt: null,
-        })
+        tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
       }
+    }
 
-      for (const { plan, thread } of activePlans) {
-        if (isPendingPlanApproval(plan)) {
-          if (plan.leadAgentId.trim()) {
-            const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
-              agentId: plan.leadAgentId,
-              counts: createEmptyCounts(),
-              tasks: [],
-              projects: [],
-              isLeadingActivePlan: false,
-              isRunning: false,
-              lastActiveAt: null,
-            }
-            activityByAgent.set(plan.leadAgentId, leadEntry)
-            leadEntry.isLeadingActivePlan = true
-            if (!leadEntry.projects.some((project) => project.planRunId === plan.runId)) {
-              leadEntry.projects.push({
-                threadId: thread.id,
-                threadTitle: thread.title,
-                planRunId: plan.runId,
-                planTitle: plan.title,
-                status: plan.status,
-              })
-            }
-            leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
-            leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
-          }
-          continue
-        }
+    return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
+  })
+}
 
-        const involvedAgents = new Set<string>()
-
-        for (const node of plan.nodes) {
-          if (node.owner.executorType !== 'agent') continue
-
-          const agentId = node.owner.ref
-          const entry =
-            activityByAgent.get(agentId) ??
-            ({
-              agentId,
-              counts: createEmptyCounts(),
-              tasks: [],
-              projects: [],
-              isLeadingActivePlan: false,
-              isRunning: false,
-              lastActiveAt: null,
-            } as AgentActivityEntry)
-          activityByAgent.set(agentId, entry)
-          involvedAgents.add(agentId)
-          incrementCounts(entry.counts, node.status)
-
-          if (!isCompletedStatus(node.status)) {
-            entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
-          }
-        }
+export function getAgentActivity(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return Effect.gen(function* () {
+    const [activePlans, userTasks] = yield* Effect.all([
+      getAllActivePlans(userRef, orgRef, deps),
+      getMyTasks(userRef, orgRef, deps),
+    ])
+    const activityByAgent = new Map<string, AgentActivityEntry>()
+
+    const agentRoster = deps.agentConfig.roster
+    for (const agentId of agentRoster) {
+      activityByAgent.set(agentId, {
+        agentId,
+        counts: createEmptyCounts(),
+        tasks: [],
+        projects: [],
+        isLeadingActivePlan: false,
+        isRunning: false,
+        lastActiveAt: null,
+      })
+    }
 
+    for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
         if (plan.leadAgentId.trim()) {
           const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
             agentId: plan.leadAgentId,
@@ -318,15 +258,8 @@ export function getAgentActivity(userRef: string, orgRef: string, deps: AgentAct
           }
           activityByAgent.set(plan.leadAgentId, leadEntry)
           leadEntry.isLeadingActivePlan = true
-          involvedAgents.add(plan.leadAgentId)
-        }
-
-        for (const agentId of involvedAgents) {
-          const entry = activityByAgent.get(agentId)
-          if (!entry) continue
-
-          if (!entry.projects.some((project) => project.planRunId === plan.runId)) {
-            entry.projects.push({
+          if (!leadEntry.projects.some((project) => project.planRunId === plan.runId)) {
+            leadEntry.projects.push({
               threadId: thread.id,
               threadTitle: thread.title,
               planRunId: plan.runId,
@@ -334,38 +267,97 @@ export function getAgentActivity(userRef: string, orgRef: string, deps: AgentAct
               status: plan.status,
             })
           }
+          leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
+          leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
+        }
+        continue
+      }
+
+      const involvedAgents = new Set<string>()
+
+      for (const node of plan.nodes) {
+        if (node.owner.executorType !== 'agent') continue
+
+        const agentId = node.owner.ref
+        const entry =
+          activityByAgent.get(agentId) ??
+          ({
+            agentId,
+            counts: createEmptyCounts(),
+            tasks: [],
+            projects: [],
+            isLeadingActivePlan: false,
+            isRunning: false,
+            lastActiveAt: null,
+          } as AgentActivityEntry)
+        activityByAgent.set(agentId, entry)
+        involvedAgents.add(agentId)
+        incrementCounts(entry.counts, node.status)
 
-          entry.isRunning = entry.isRunning || thread.isRunning
-          entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
+        if (!isCompletedStatus(node.status)) {
+          entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
         }
       }
 
-      const agents = [...activityByAgent.values()].sort((left, right) => {
-        const leftIndex = agentRoster.indexOf(left.agentId)
-        const rightIndex = agentRoster.indexOf(right.agentId)
-        if (leftIndex !== -1 || rightIndex !== -1) {
-          if (leftIndex === -1) return 1
-          if (rightIndex === -1) return -1
-          return leftIndex - rightIndex
+      if (plan.leadAgentId.trim()) {
+        const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
+          agentId: plan.leadAgentId,
+          counts: createEmptyCounts(),
+          tasks: [],
+          projects: [],
+          isLeadingActivePlan: false,
+          isRunning: false,
+          lastActiveAt: null,
         }
-        return left.agentId.localeCompare(right.agentId)
-      })
+        activityByAgent.set(plan.leadAgentId, leadEntry)
+        leadEntry.isLeadingActivePlan = true
+        involvedAgents.add(plan.leadAgentId)
+      }
 
-      return {
-        agents,
-        userActivity: {
-          taskCount: userTasks.tasks.length,
-          pendingApprovalCount: userTasks.pendingApprovalCount,
-          awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
-          lastActiveAt: activePlans.reduce<string | null>(
-            (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
-            null,
-          ),
-        },
-        totalActivePlans: activePlans.length,
+      for (const agentId of involvedAgents) {
+        const entry = activityByAgent.get(agentId)
+        if (!entry) continue
+
+        if (!entry.projects.some((project) => project.planRunId === plan.runId)) {
+          entry.projects.push({
+            threadId: thread.id,
+            threadTitle: thread.title,
+            planRunId: plan.runId,
+            planTitle: plan.title,
+            status: plan.status,
+          })
+        }
+
+        entry.isRunning = entry.isRunning || thread.isRunning
+        entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
+      }
+    }
+
+    const agents = [...activityByAgent.values()].sort((left, right) => {
+      const leftIndex = agentRoster.indexOf(left.agentId)
+      const rightIndex = agentRoster.indexOf(right.agentId)
+      if (leftIndex !== -1 || rightIndex !== -1) {
+        if (leftIndex === -1) return 1
+        if (rightIndex === -1) return -1
+        return leftIndex - rightIndex
       }
-    }),
-  )
+      return left.agentId.localeCompare(right.agentId)
+    })
+
+    return {
+      agents,
+      userActivity: {
+        taskCount: userTasks.tasks.length,
+        pendingApprovalCount: userTasks.pendingApprovalCount,
+        awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
+        lastActiveAt: activePlans.reduce<string | null>(
+          (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
+          null,
+        ),
+      },
+      totalActivePlans: activePlans.length,
+    }
+  })
 }
 
 export function getAllActivePlans(userRef: string, orgRef: string, deps: AgentActivityDeps) {
@@ -446,14 +438,15 @@ export function createAgentActivityService(deps: AgentActivityDeps | (() => Agen
 export type AgentActivityService = ReturnType<typeof createAgentActivityService>
 
 export class AgentActivityServiceTag extends Context.Service<AgentActivityServiceTag, AgentActivityService>()(
-  'AgentActivityService',
+  '@lota-sdk/core/AgentActivityService',
 ) {}
 
 export const AgentActivityServiceLive = Layer.effect(
   AgentActivityServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const executionPlanService = yield* ExecutionPlanServiceTag
     const threadService = yield* ThreadServiceTag
-    return createAgentActivityService({ executionPlanService, threadService })
+    return createAgentActivityService({ agentConfig, executionPlanService, threadService })
   }),
 )