Add team-based chat routing and auto-assignment

- Add Team and TeamMember models for organizing agents into teams
- Implement assignment strategies: round-robin, load-balanced, manual queue
- Add Teams API with CRUD endpoints and role-based access control
- Add "Transfer" step type in conversation flows to route to specific teams
- Update transfers view with team filtering and per-team queue counts
- Create Teams management page under Settings
- Agents can pick transfers from teams they belong to

Author: shridarpatil

cmd/server/main.go

@@ -409,6 +409,16 @@ func setupRoutes(g *fastglue.Fastglue, app *handlers.App, lo logf.Logger, basePa
 	g.PUT("/api/chatbot/transfers/{id}/resume", app.ResumeFromTransfer)
 	g.PUT("/api/chatbot/transfers/{id}/assign", app.AssignAgentTransfer)
 
+	// Teams (admin/manager - access control in handler)
+	g.GET("/api/teams", app.ListTeams)
+	g.POST("/api/teams", app.CreateTeam)
+	g.GET("/api/teams/{id}", app.GetTeam)
+	g.PUT("/api/teams/{id}", app.UpdateTeam)
+	g.DELETE("/api/teams/{id}", app.DeleteTeam)
+	g.GET("/api/teams/{id}/members", app.ListTeamMembers)
+	g.POST("/api/teams/{id}/members", app.AddTeamMember)
+	g.DELETE("/api/teams/{id}/members/{user_id}", app.RemoveTeamMember)
+
 	// Canned Responses
 	g.GET("/api/canned-responses", app.ListCannedResponses)
 	g.POST("/api/canned-responses", app.CreateCannedResponse)

frontend/src/components/layout/AppLayout.vue

@@ -186,6 +186,7 @@ const allNavItems = [
       { name: 'General', path: '/settings', icon: Settings },
       { name: 'Accounts', path: '/settings/accounts', icon: Users },
       { name: 'Canned Responses', path: '/settings/canned-responses', icon: MessageSquareText },
+      { name: 'Teams', path: '/settings/teams', icon: Users },
       { name: 'Users', path: '/settings/users', icon: Users, roles: ['admin'] },
       { name: 'API Keys', path: '/settings/api-keys', icon: Key, roles: ['admin'] },
       { name: 'Webhooks', path: '/settings/webhooks', icon: Webhook, roles: ['admin'] },

frontend/src/router/index.ts

@@ -148,6 +148,12 @@ const router = createRouter({
           component: () => import('@/views/settings/UsersView.vue'),
           meta: { roles: ['admin'] }
         },
+        {
+          path: 'settings/teams',
+          name: 'teams',
+          component: () => import('@/views/settings/TeamsView.vue'),
+          meta: { roles: ['admin', 'manager'] }
+        },
         {
           path: 'settings/api-keys',
           name: 'api-keys',

frontend/src/services/api.ts

@@ -303,6 +303,54 @@ export interface WebhookEvent {
   description: string
 }
 
+export interface Team {
+  id: string
+  name: string
+  description: string
+  assignment_strategy: 'round_robin' | 'load_balanced' | 'manual'
+  is_active: boolean
+  member_count: number
+  created_at: string
+  updated_at: string
+}
+
+export interface TeamMember {
+  id: string
+  team_id: string
+  user_id: string
+  role: 'manager' | 'agent'
+  last_assigned_at: string | null
+  user: {
+    id: string
+    full_name: string
+    email: string
+    is_available: boolean
+  }
+}
+
+export const teamsService = {
+  list: () => api.get<{ teams: Team[] }>('/teams'),
+  get: (id: string) => api.get<{ team: Team }>(`/teams/${id}`),
+  create: (data: {
+    name: string
+    description?: string
+    assignment_strategy?: 'round_robin' | 'load_balanced' | 'manual'
+  }) => api.post<{ team: Team }>('/teams', data),
+  update: (id: string, data: {
+    name?: string
+    description?: string
+    assignment_strategy?: 'round_robin' | 'load_balanced' | 'manual'
+    is_active?: boolean
+  }) => api.put<{ team: Team }>(`/teams/${id}`, data),
+  delete: (id: string) => api.delete(`/teams/${id}`),
+  // Members
+  listMembers: (teamId: string) => api.get<{ members: TeamMember[] }>(`/teams/${teamId}/members`),
+  addMember: (teamId: string, data: { user_id: string; role?: 'manager' | 'agent' }) =>
+    api.post<{ member: TeamMember }>(`/teams/${teamId}/members`, data),
+  removeMember: (teamId: string, userId: string) =>
+    api.delete(`/teams/${teamId}/members/${userId}`)
+}
+
 export const webhooksService = {
   list: () => api.get<{ webhooks: Webhook[]; available_events: WebhookEvent[] }>('/webhooks'),
   get: (id: string) => api.get<Webhook>(`/webhooks/${id}`),

frontend/src/stores/teams.ts

@@ -0,0 +1,142 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import { teamsService, type Team, type TeamMember } from '@/services/api'
+
+export interface CreateTeamData {
+  name: string
+  description?: string
+  assignment_strategy?: 'round_robin' | 'load_balanced' | 'manual'
+}
+
+export interface UpdateTeamData {
+  name?: string
+  description?: string
+  assignment_strategy?: 'round_robin' | 'load_balanced' | 'manual'
+  is_active?: boolean
+}
+
+export const useTeamsStore = defineStore('teams', () => {
+  const teams = ref<Team[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchTeams(): Promise<void> {
+    loading.value = true
+    error.value = null
+    try {
+      const response = await teamsService.list()
+      teams.value = response.data.data.teams || []
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to fetch teams'
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function createTeam(data: CreateTeamData): Promise<Team> {
+    loading.value = true
+    error.value = null
+    try {
+      const response = await teamsService.create(data)
+      const newTeam = response.data.data.team
+      teams.value.unshift(newTeam)
+      return newTeam
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to create team'
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function updateTeam(id: string, data: UpdateTeamData): Promise<Team> {
+    loading.value = true
+    error.value = null
+    try {
+      const response = await teamsService.update(id, data)
+      const updatedTeam = response.data.data.team
+      const index = teams.value.findIndex(t => t.id === id)
+      if (index !== -1) {
+        teams.value[index] = updatedTeam
+      }
+      return updatedTeam
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to update team'
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function deleteTeam(id: string): Promise<void> {
+    loading.value = true
+    error.value = null
+    try {
+      await teamsService.delete(id)
+      teams.value = teams.value.filter(t => t.id !== id)
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to delete team'
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function fetchTeamMembers(teamId: string): Promise<TeamMember[]> {
+    try {
+      const response = await teamsService.listMembers(teamId)
+      return response.data.data.members || []
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to fetch team members'
+      throw err
+    }
+  }
+
+  async function addTeamMember(teamId: string, userId: string, role: 'manager' | 'agent' = 'agent'): Promise<TeamMember> {
+    try {
+      const response = await teamsService.addMember(teamId, { user_id: userId, role })
+      // Update member count
+      const team = teams.value.find(t => t.id === teamId)
+      if (team) {
+        team.member_count = (team.member_count || 0) + 1
+      }
+      return response.data.data.member
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to add team member'
+      throw err
+    }
+  }
+
+  async function removeTeamMember(teamId: string, userId: string): Promise<void> {
+    try {
+      await teamsService.removeMember(teamId, userId)
+      // Update member count
+      const team = teams.value.find(t => t.id === teamId)
+      if (team && team.member_count > 0) {
+        team.member_count = team.member_count - 1
+      }
+    } catch (err: any) {
+      error.value = err.response?.data?.message || 'Failed to remove team member'
+      throw err
+    }
+  }
+
+  function getTeamById(id: string): Team | undefined {
+    return teams.value.find(t => t.id === id)
+  }
+
+  return {
+    teams,
+    loading,
+    error,
+    fetchTeams,
+    createTeam,
+    updateTeam,
+    deleteTeam,
+    fetchTeamMembers,
+    addTeamMember,
+    removeTeamMember,
+    getTeamById
+  }
+})

frontend/src/stores/transfers.ts

@@ -12,6 +12,8 @@ export interface AgentTransfer {
   source: 'manual' | 'flow' | 'keyword'
   agent_id?: string
   agent_name?: string
+  team_id?: string
+  team_name?: string
   transferred_by?: string
   transferred_by_name?: string
   notes?: string
@@ -23,9 +25,16 @@ export interface AgentTransfer {
 
 export const useTransfersStore = defineStore('transfers', () => {
   const transfers = ref<AgentTransfer[]>([])
-  const queueCount = ref(0)
+  const generalQueueCount = ref(0)
+  const teamQueueCounts = ref<Record<string, number>>({})
   const isLoading = ref(false)
 
+  // Total queue count (general + all teams)
+  const queueCount = computed(() => {
+    const teamTotal = Object.values(teamQueueCounts.value).reduce((sum, count) => sum + count, 0)
+    return generalQueueCount.value + teamTotal
+  })
+
   const activeTransfers = computed(() =>
     transfers.value.filter(t => t.status === 'active')
   )
@@ -54,8 +63,9 @@ export const useTransfersStore = defineStore('transfers', () => {
       const data = response.data.data || response.data
       console.log('Parsed transfers data:', data)
       transfers.value = data.transfers || []
-      queueCount.value = data.queue_count ?? 0
-      console.log('Queue count:', queueCount.value, 'Transfers:', transfers.value.length)
+      generalQueueCount.value = data.general_queue_count ?? 0
+      teamQueueCounts.value = data.team_queue_counts ?? {}
+      console.log('General queue:', generalQueueCount.value, 'Team queues:', teamQueueCounts.value, 'Transfers:', transfers.value.length)
     } catch (error) {
       console.error('Failed to fetch transfers:', error)
     } finally {
@@ -69,7 +79,11 @@ export const useTransfersStore = defineStore('transfers', () => {
     if (!exists) {
       transfers.value.unshift(transfer)
       if (!transfer.agent_id) {
-        queueCount.value++
+        if (transfer.team_id) {
+          teamQueueCounts.value[transfer.team_id] = (teamQueueCounts.value[transfer.team_id] || 0) + 1
+        } else {
+          generalQueueCount.value++
+        }
       }
       console.log('Transfer added to store:', transfer.id, 'Total:', transfers.value.length, 'Queue count:', queueCount.value)
     } else {
@@ -86,15 +100,30 @@ export const useTransfersStore = defineStore('transfers', () => {
       // Update queue count if assignment changed
       if (updates.agent_id !== undefined) {
         if (!oldTransfer.agent_id && updates.agent_id) {
-          queueCount.value = Math.max(0, queueCount.value - 1)
+          // Was unassigned, now assigned - decrease queue count
+          if (oldTransfer.team_id) {
+            teamQueueCounts.value[oldTransfer.team_id] = Math.max(0, (teamQueueCounts.value[oldTransfer.team_id] || 0) - 1)
+          } else {
+            generalQueueCount.value = Math.max(0, generalQueueCount.value - 1)
+          }
         } else if (oldTransfer.agent_id && !updates.agent_id) {
-          queueCount.value++
+          // Was assigned, now unassigned - increase queue count
+          const teamId = updates.team_id ?? oldTransfer.team_id
+          if (teamId) {
+            teamQueueCounts.value[teamId] = (teamQueueCounts.value[teamId] || 0) + 1
+          } else {
+            generalQueueCount.value++
+          }
         }
       }
 
       // Update queue count if status changed to resumed
       if (updates.status === 'resumed' && oldTransfer.status === 'active' && !oldTransfer.agent_id) {
-        queueCount.value = Math.max(0, queueCount.value - 1)
+        if (oldTransfer.team_id) {
+          teamQueueCounts.value[oldTransfer.team_id] = Math.max(0, (teamQueueCounts.value[oldTransfer.team_id] || 0) - 1)
+        } else {
+          generalQueueCount.value = Math.max(0, generalQueueCount.value - 1)
+        }
       }
     }
   }
@@ -104,7 +133,11 @@ export const useTransfersStore = defineStore('transfers', () => {
     if (index !== -1) {
       const transfer = transfers.value[index]
       if (transfer.status === 'active' && !transfer.agent_id) {
-        queueCount.value = Math.max(0, queueCount.value - 1)
+        if (transfer.team_id) {
+          teamQueueCounts.value[transfer.team_id] = Math.max(0, (teamQueueCounts.value[transfer.team_id] || 0) - 1)
+        } else {
+          generalQueueCount.value = Math.max(0, generalQueueCount.value - 1)
+        }
       }
       transfers.value.splice(index, 1)
     }
@@ -113,6 +146,8 @@ export const useTransfersStore = defineStore('transfers', () => {
   return {
     transfers,
     queueCount,
+    generalQueueCount,
+    teamQueueCounts,
     isLoading,
     activeTransfers,
     myTransfers,