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

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,11 +23,13 @@ export interface Event {
     | 'stack'
     | 'restart'
     | 'session_ended'
+    | AgentEvents
   text?: string
   timestamp: string
   update?: string
   parse_data?: { commands: Command[] }
-  metadata?: { utter_action?: string }
+  metadata?: { utter_action?: string; execution_times?: RasaLatency }
+  name?: string
 }
 
 export interface Command {
@@ -40,15 +52,21 @@ export interface Stack {
   collect?: string
   utter?: string
   ended: boolean
+  type: "flow" | "agent"
   agent_id?: string
   state?: "waiting_for_input" | "interrupted"
 }
 
-export interface LatencyData {
-  rasa_processing_latency_ms?: number
-  asr_latency_ms?: number
-  tts_first_byte_latency_ms?: number
-  tts_complete_latency_ms?: number
+export interface RasaLatency {
+  command_processor: number
+  prediction_loop: number
+}
+
+export interface VoiceLatency {
+  rasa_processing_latency_ms: number
+  asr_latency_ms: number
+  tts_first_byte_latency_ms: number
+  tts_complete_latency_ms: number
 }
 
 export interface Tracker {
@@ -56,7 +74,6 @@ export interface Tracker {
   slots: { [key: string]: unknown }
   events: Event[]
   stack: Stack[]
-  latency?: LatencyData
 }
 
 export interface Flow {
@@ -66,6 +83,11 @@ export interface Flow {
   steps: Step[]
 }
 
+export interface Agent {
+  name: string
+  status: "running" | "completed" | "interrupted" | "cancelled"
+}
+
 interface NextStepThen {
   action: string
   id: string
@@ -100,3 +122,23 @@ interface Step {
   call?: string
   noop?: boolean
 }
+
+export function isRasaLatency(obj: any): obj is RasaLatency {
+  return (
+    obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.command_processor === 'number' &&
+    typeof obj.prediction_loop === 'number'
+  )
+}
+
+export function isVoiceLatency(obj: any): obj is VoiceLatency {
+  return (
+    obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.rasa_processing_latency_ms === 'number' &&
+    typeof obj.asr_latency_ms === 'number' &&
+    typeof obj.tts_first_byte_latency_ms === 'number' &&
+    typeof obj.tts_complete_latency_ms === 'number'
+  )
+}