rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev7__py3-none-any.whl

rasa/core/channels/inspector/src/App.tsx

@@ -9,28 +9,30 @@ import { useEffect, useState, useCallback } from 'react'
 import axios from 'axios'
 import { useOurTheme } from './theme'
 import { Welcome } from './components/Welcome'
-import { DialogueStack } from './components/DialogueStack'
+import { DialogueHistoryStack } from './components/DialogueHistoryStack.tsx'
 import { DialougeInformation } from './components/DialogueInformation'
 import { LoadingSpinner } from './components/LoadingSpinner'
 import { DiagramFlow } from './components/DiagramFlow'
 import { RecruitmentPanel } from './components/RecruitmentPanel'
 import { formatSlots } from './helpers/formatters'
-import { Slot, Stack, Event, Flow, SelectedStack, Tracker } from './types'
+import {Slot, Stack, Event, Flow, SelectedStack, Tracker, Agent} from './types'
 import {
   createHistoricalStack,
-  flowStepTrail,
+  flowStepTrail, updateAgentsStatus,
   updatedActiveFrame,
 } from './helpers/utils'
 import queryString from 'query-string'
 import { Chat } from './components/Chat'
 import { LatencyDisplay } from './components/LatencyDisplay'
 import useWebSocket, { ReadyState } from 'react-use-websocket'
+import {DialogueAgentStack} from "./components/DialogueAgentStack.tsx";
 
 export function App() {
   const toast = useToast()
   const { rasaSpace, rasaRadii } = useOurTheme()
   const [rasaChatSessionId, setRasaChatSessionId] = useState<string>('')
   const [flows, setFlows] = useState<Flow[]>([])
+  const [agents, setAgents] = useState<Agent[]>([])
   const [slots, setSlots] = useState<Slot[]>([])
   const [events, setEvents] = useState<Event[]>([])
   const [story, setStory] = useState<string>('')
@@ -102,6 +104,23 @@ export function App() {
       })
   }, [toast])
 
+  useEffect(() => {
+    axios
+      .get('/sub-agents', { params: { token } })
+      .then((response) => setAgents((response.data)))
+      .catch((error) => {
+        if (toast.isActive('agents')) return
+        toast({
+          id: 'agents',
+          title: 'Agents could not be retrieved',
+          description: error?.message || 'An unknown error happened.',
+          status: 'error',
+          duration: 4000,
+          isClosable: true,
+        })
+      })
+  }, [toast])
+
   function fetchStory() {
     axios
       .get(`/conversations/${rasaChatSessionId}/story`, { params: { token } })
@@ -142,6 +161,7 @@ export function App() {
         lastJsonMessage.stack,
         lastJsonMessage.events,
       )
+      setAgents(prevAgents => updateAgentsStatus(prevAgents, lastJsonMessage.events))
       setStack(updatedStack)
       setFrame(updatedActiveFrame(frame, updatedStack, lastJsonMessage.events))
       setRasaChatSessionId(lastJsonMessage.sender_id)
@@ -240,12 +260,16 @@ export function App() {
           {showRecruitmentPanel && (
             <RecruitmentPanel onClose={handleCloseRecruitmentPanel} />
           )}
-          <DialogueStack
+          <DialogueHistoryStack
             sx={boxSx}
             stack={stack}
             active={frame?.stack}
             onItemClick={onFrameSelected}
           />
+          {agents.length > 0 ? (<DialogueAgentStack
+            sx={boxSx}
+            agents={agents}
+          />):null}
           <DialougeInformation
             sx={boxSx}
             rasaChatSessionId={rasaChatSessionId}

rasa/core/channels/inspector/src/components/DialogueAgentStack.tsx

@@ -0,0 +1,108 @@
+import {
+  Box,
+  FlexProps,
+  Heading,
+  Table,
+  Thead,
+  Tbody,
+  Tr,
+  Th,
+  Td,
+  Text,
+  Flex,
+} from '@chakra-ui/react'
+import { useOurTheme } from '../theme'
+import {Agent, Stack} from '../types'
+
+function mapStatusToHumanReadableName(status: Agent['status']) {
+  switch (status) {
+    case 'running':
+      return 'Running'
+    case 'completed':
+      return 'Completed'
+    case 'interrupted':
+      return 'Interrupted'
+    case 'cancelled':
+      return 'Cancelled'
+    default:
+      return '-'
+  }
+}
+
+interface Props extends FlexProps {
+  agents: Agent[]
+  active?: Stack
+  onItemClick?: (stack: Stack) => void
+}
+
+function AgentRow({
+  agent,
+}: {
+  agent: Agent
+}) {
+
+  return (
+    <Tr>
+      <Td>
+          <Text noOfLines={1}>{agent.name}</Text>
+      </Td>
+      <Td>
+          <Text noOfLines={1}>{mapStatusToHumanReadableName(agent.status)}</Text>
+      </Td>
+    </Tr>
+  )
+}
+
+export const DialogueAgentStack = ({
+  sx,
+  agents,
+  active,
+  onItemClick,
+  ...props
+}: Props) => {
+  const { rasaSpace } = useOurTheme()
+
+  const containerSx = {
+    ...sx,
+    pr: 0,
+    pb: 0,
+    flexDirection: 'column',
+  }
+  const overflowBox = {
+    height: '100%',
+    overflow: 'auto',
+    pr: rasaSpace[1],
+    pb: rasaSpace[0.5],
+  }
+
+  return (
+    <Flex sx={containerSx} {...props}>
+      <Flex>
+        <Heading size="lg" mb={rasaSpace[0.5]}>
+          Agents
+        </Heading>
+        <Text ml={rasaSpace[0.25]}>({agents.length} {agents.length === 1 ? 'agent' : 'agents'})</Text>
+      </Flex>
+      <Box sx={overflowBox}>
+        <Table width="100%" layout="fixed">
+          <Thead>
+            <Tr>
+              <Th>Name</Th>
+              <Th width="40%">Status</Th>
+            </Tr>
+          </Thead>
+          <Tbody>
+            {agents.length > 0 &&
+              [...agents]
+                .reverse()
+                .map((agent) => (
+                  <AgentRow
+                    agent={agent}
+                  />
+                ))}
+          </Tbody>
+        </Table>
+      </Box>
+    </Flex>
+  )
+}

rasa/core/channels/inspector/src/components/{DialogueStack.tsx → DialogueHistoryStack.tsx}

@@ -52,8 +52,6 @@ function StackRow({
     },
   }
 
-  const agentOrStep = stack.agent_id ?? stack.step_id;
-
   return (
     <Tr
       sx={
@@ -67,19 +65,19 @@ function StackRow({
         </Tooltip>
       </Td>
       <Td>
-        {shouldShowTooltip(agentOrStep) ? (
-          <Tooltip label={`${agentOrStep} ${stack.agent_id && `(${stack.step_id})`}`} hasArrow>
-            <Text noOfLines={1}>{agentOrStep}</Text>
+        {shouldShowTooltip(stack.step_id) ? (
+          <Tooltip label={stack.step_id} hasArrow>
+            <Text noOfLines={1}>{stack.step_id}</Text>
           </Tooltip>
         ) : (
-          <Text noOfLines={1}>{agentOrStep}</Text>
+          <Text noOfLines={1}>{stack.step_id}</Text>
         )}
       </Td>
     </Tr>
   )
 }
 
-export const DialogueStack = ({
+export const DialogueHistoryStack = ({
   sx,
   stack,
   active,
@@ -107,7 +105,7 @@ export const DialogueStack = ({
         <Heading size="lg" mb={rasaSpace[0.5]}>
           History
         </Heading>
-        <Text ml={rasaSpace[0.25]}>({stack.length} flows)</Text>
+        <Text ml={rasaSpace[0.25]}>({stack.length} {stack.length === 1 ? 'flow' : 'flows'})</Text>
       </Flex>
       <Box sx={overflowBox}>
         <Table width="100%" layout="fixed">
@@ -136,6 +134,7 @@ export const DialogueStack = ({
                   flow_id: '-',
                   step_id: '-',
                   ended: false,
+                  type: "flow"
                 }}
               />
             )}

rasa/core/channels/inspector/src/helpers/formatters.test.ts

@@ -294,6 +294,7 @@ describe('helpers', () => {
           step_id: 'step_id',
           collect: fieldValue,
           ended: false,
+          type: 'flow',
         }),
       ).toEqual(fieldValue)
     })
@@ -307,6 +308,7 @@ describe('helpers', () => {
           flow_id: 'flow_id',
           step_id: 'step_id',
           ended: false,
+          type: 'flow',
         }),
       ).toEqual(fieldValue)
     })
@@ -321,6 +323,7 @@ describe('helpers', () => {
           step_id: 'step_id',
           collect: fieldValue,
           ended: false,
+          type: 'flow',
         }),
       ).toEqual(`${fieldValue} is not null`)
     })
@@ -335,6 +338,7 @@ describe('helpers', () => {
           step_id: 'step_id',
           collect: fieldValue,
           ended: false,
+          type: 'flow',
         }),
       ).toEqual(`not ${fieldValue}`)
     })

rasa/core/channels/inspector/src/helpers/utils.test.ts

@@ -0,0 +1,127 @@
+import { updateAgentsStatus } from './utils'
+import type { Agent, Event } from '../types'
+
+// Helper to clone agents (immutability check)
+const clone = <T>(x: T): T => JSON.parse(JSON.stringify(x))
+
+describe('updateAgentsStatus', () => {
+  test('returns empty array when agents undefined', () => {
+    // @ts-expect-error testing runtime behavior with undefined
+    expect(updateAgentsStatus(undefined, [])).toEqual([])
+  })
+
+  test('returns same agents when agents empty', () => {
+    const agents: Agent[] = []
+    const events: Event[] = [
+      { event: 'agent_started', timestamp: '1' } as any,
+    ]
+    expect(updateAgentsStatus(agents, events)).toEqual([])
+  })
+
+  test('returns same agents when events empty', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'completed' },
+    ]
+    const events: Event[] = []
+    expect(updateAgentsStatus(clone(agents), events)).toEqual(agents)
+  })
+
+  test('ignores non-agent events', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'completed' },
+    ]
+    const events: Event[] = [
+      { event: 'user', text: 'hi', timestamp: '1' } as any,
+      { event: 'bot', text: 'hey', timestamp: '2' } as any,
+    ]
+    expect(updateAgentsStatus(clone(agents), events)).toEqual(agents)
+  })
+
+  test('uses latest event by timestamp per agent', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'completed' },
+      { name: 'beta', status: 'completed' },
+    ]
+
+    const events: Event[] = [
+      { event: 'agent_started', agent_id: 'alpha', timestamp: 1 } as any,
+      { event: 'agent_interrupted', agent_id: 'alpha', timestamp: 2 } as any,
+      { event: 'agent_resumed', agent_id: 'alpha', timestamp: 3 } as any,
+      { event: 'agent_cancelled', agent_id: 'beta', timestamp: 5 } as any,
+    ]
+
+    const result = updateAgentsStatus(clone(agents), events)
+    expect(result).toEqual([
+      { name: 'alpha', status: 'running' },
+      { name: 'beta', status: 'cancelled' },
+    ])
+  })
+
+  test('later event wins when timestamps missing', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'completed' },
+    ]
+
+    const events: Event[] = [
+      { event: 'agent_started', agent_id: 'alpha', timestamp: null } as any,
+      { event: 'agent_interrupted', agent_id: 'alpha', timestamp: null } as any,
+    ]
+
+    const result = updateAgentsStatus(clone(agents), events)
+    expect(result).toEqual([
+      { name: 'alpha', status: 'interrupted' },
+    ])
+  })
+
+  test('agent_completed maps to provided status and falls back to completed', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'running' },
+      { name: 'beta', status: 'running' },
+    ]
+
+    const events: Event[] = [
+      { event: 'agent_completed', agent_id: 'alpha', status: 'completed', timestamp: 10 } as any,
+      { event: 'agent_completed', agent_id: 'beta', timestamp: 10 } as any,
+    ]
+
+    const result = updateAgentsStatus(clone(agents), events)
+    expect(result).toEqual([
+      { name: 'alpha', status: 'completed' },
+      { name: 'beta', status: 'completed' },
+    ])
+  })
+
+  test('unmatched agents remain unchanged', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'running' },
+      { name: 'gamma', status: 'interrupted' },
+    ]
+
+    const events: Event[] = [
+      { event: 'agent_resumed', agent_id: 'alpha', timestamp: 1 } as any,
+      { event: 'agent_cancelled', agent_id: 'beta', timestamp: 2 } as any, // beta not in agents list
+    ]
+
+    const result = updateAgentsStatus(clone(agents), events)
+    expect(result).toEqual([
+      { name: 'alpha', status: 'running' },
+      { name: 'gamma', status: 'interrupted' },
+    ])
+  })
+
+  test('handles mixed timestamp types (string/number)', () => {
+    const agents: Agent[] = [
+      { name: 'alpha', status: 'completed' },
+    ]
+
+    const events: Event[] = [
+      { event: 'agent_started', agent_id: 'alpha', timestamp: '1' } as any,
+      { event: 'agent_interrupted', agent_id: 'alpha', timestamp: 2 } as any,
+    ]
+
+    const result = updateAgentsStatus(clone(agents), events)
+    expect(result).toEqual([
+      { name: 'alpha', status: 'interrupted' },
+    ])
+  })
+})

rasa/core/channels/inspector/src/helpers/utils.ts

@@ -1,4 +1,4 @@
-import { SelectedStack, Stack, Event } from '../types'
+import {SelectedStack, Stack, Event, Agent, AGENT_EVENT_TYPES} from '../types'
 import { immutableJSONPatch } from 'immutable-json-patch'
 
 export const shouldShowTooltip = (text: string) => {
@@ -146,3 +146,68 @@ export const updatedActiveFrame = (
     return previous
   }
 }
+
+export function updateAgentsStatus(agents: Agent[], events: Event[]): Agent[] {
+  if (!agents || agents.length === 0 || !events || events.length === 0) {
+    return agents || []
+  }
+
+  const agentEventTypes = new Set<Event['event']>(AGENT_EVENT_TYPES as unknown as Event['event'][] )
+
+  type AgentEventLite = Agent & {
+    agent_id: string
+    event: Event['event']
+    timestamp?: string | number | null
+  }
+  
+  const latestByAgent = new Map<string, AgentEventLite>()
+
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i] as unknown as AgentEventLite
+    if (!event || !agentEventTypes.has(event.event)) continue
+
+    const agentId = event.agent_id
+    if (!agentId) continue
+
+    const previousEvent = latestByAgent.get(agentId)
+
+    const currentTimestamp = event.timestamp == null ? undefined : Number(event.timestamp)
+    const previousTimestamp = previousEvent?.timestamp == null ? undefined : Number(previousEvent.timestamp)
+
+    const isNewer =
+      previousEvent == null ||
+      (currentTimestamp != null && previousTimestamp != null && currentTimestamp > previousTimestamp) ||
+      (currentTimestamp != null && previousTimestamp == null)
+    // If both timestamps are missing, prefer later in the array (current)
+
+    if (isNewer || (currentTimestamp == null && previousTimestamp == null)) {
+      latestByAgent.set(agentId, event)
+    }
+  }
+
+  return agents.map((agent) => {
+    const latest = latestByAgent.get(agent.name)
+    if (!latest) return agent
+
+    let status = agent.status
+    switch (latest.event) {
+      case 'agent_started':
+      case 'agent_resumed':
+        status = 'running'
+        break
+      case 'agent_interrupted':
+        status = 'interrupted'
+        break
+      case 'agent_cancelled':
+        status = 'cancelled'
+        break
+      case 'agent_completed':
+        status = latest.status || 'completed'
+        break
+      default:
+        break
+    }
+
+    return { ...agent, status }
+  })
+}

rasa/core/channels/inspector/src/types.ts

@@ -4,6 +4,16 @@ export interface Slot {
   value: any
 }
 
+export const AGENT_EVENT_TYPES = [
+  'agent_started',
+  'agent_completed',
+  'agent_interrupted',
+  'agent_resumed',
+  'agent_cancelled',
+] as const
+
+export type AgentEvents = typeof AGENT_EVENT_TYPES[number];
+
 export interface Event {
   event:
     | 'user'
@@ -13,6 +23,7 @@ export interface Event {
     | 'stack'
     | 'restart'
     | 'session_ended'
+    | AgentEvents
   text?: string
   timestamp: string
   update?: string
@@ -40,6 +51,7 @@ export interface Stack {
   collect?: string
   utter?: string
   ended: boolean
+  type: "flow" | "agent"
   agent_id?: string
   state?: "waiting_for_input" | "interrupted"
 }
@@ -66,6 +78,11 @@ export interface Flow {
   steps: Step[]
 }
 
+export interface Agent {
+  name: string
+  status: "running" | "completed" | "interrupted" | "cancelled"
+}
+
 interface NextStepThen {
   action: string
   id: string

rasa/core/policies/flows/flow_executor.py

@@ -65,7 +65,10 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     AgentState,
     FlowStackFrameType,
 )
-from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.dialogue_understanding.stack.utils import (
+    user_frames_on_the_stack,
+)
+from rasa.dialogue_understanding.utils import assemble_options_string
 from rasa.shared.agents.utils import get_protocol_type
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
@@ -263,38 +266,58 @@ def trigger_pattern_continue_interrupted(
     stack: DialogueStack,
     flows: FlowsList,
     tracker: DialogueStateTracker,
-) -> List[Event]:
+) -> None:
     """Trigger the pattern to continue an interrupted flow if needed."""
-    events: List[Event] = []
-
-    # get previously started user flow that will be continued
-    interrupted_user_flow_frame = top_user_flow_frame(stack)
-    interrupted_user_flow_step = (
-        interrupted_user_flow_frame.step(flows) if interrupted_user_flow_frame else None
-    )
-    interrupted_user_flow = (
-        interrupted_user_flow_frame.flow(flows) if interrupted_user_flow_frame else None
-    )
-
+    # only trigger the pattern if the current frame is a user flow frame
+    # with a frame type of interrupt
     if (
-        isinstance(current_frame, UserFlowStackFrame)
-        and interrupted_user_flow_step is not None
-        and interrupted_user_flow is not None
-        and current_frame.frame_type == FlowStackFrameType.INTERRUPT
-        and not is_step_end_of_flow(interrupted_user_flow_step)
+        not isinstance(current_frame, UserFlowStackFrame)
+        or current_frame.frame_type != FlowStackFrameType.INTERRUPT
     ):
-        stack.push(
-            ContinueInterruptedPatternFlowStackFrame(
-                previous_flow_name=interrupted_user_flow.readable_name(
-                    language=tracker.current_language
-                ),
-            )
+        return None
+
+    # get all previously interrupted user flows
+    interrupted_user_flow_stack_frames = user_frames_on_the_stack(stack)
+
+    interrupted_user_flows_to_continue: List[UserFlowStackFrame] = []
+    # check if interrupted user flows can be continued
+    # i.e. the flow is not at the end of the flow
+    for frame in interrupted_user_flow_stack_frames:
+        interrupted_user_flow_step = frame.step(flows)
+        interrupted_user_flow = frame.flow(flows)
+        if (
+            interrupted_user_flow_step is not None
+            and interrupted_user_flow is not None
+            and not is_step_end_of_flow(interrupted_user_flow_step)
+        ):
+            interrupted_user_flows_to_continue.append(frame)
+
+    # if there are no interrupted user flows to continue,
+    # we don't need to trigger the pattern
+    if len(interrupted_user_flows_to_continue) == 0:
+        return None
+
+    # get the flow names and ids of the interrupted flows
+    # and assemble the options string
+    flow_names: List[str] = []
+    flow_ids: List[str] = []
+    for frame in interrupted_user_flows_to_continue:
+        flow_names.append(
+            frame.flow(flows).readable_name(language=tracker.current_language)
         )
-        events.append(
-            FlowResumed(interrupted_user_flow.id, interrupted_user_flow_step.id)
+        flow_ids.append(frame.flow_id)
+    options_string = assemble_options_string(flow_names)
+
+    # trigger the pattern to continue the interrupted flows
+    stack.push(
+        ContinueInterruptedPatternFlowStackFrame(
+            interrupted_flow_names=flow_names,
+            interrupted_flow_ids=flow_ids,
+            interrupted_flow_options=options_string,
         )
+    )
 
-    return events
+    return None
 
 
 def trigger_pattern_completed(
@@ -707,12 +730,10 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(current_frame, stack, flows)
-    resumed_events = trigger_pattern_continue_interrupted(
-        current_frame, stack, flows, tracker
-    )
+    trigger_pattern_continue_interrupted(current_frame, stack, flows, tracker)
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
-        events=initial_events + reset_events + resumed_events, has_flow_ended=True
+        events=initial_events + reset_events, has_flow_ended=True
     )