@roj-ai/shared 0.0.2

package/src/projections/agent-tree-projection.ts

@@ -0,0 +1,229 @@
+/**
+ * Agent tree projection - self-contained projection for building agent tree.
+ *
+ * Replaces the old buildAgentTree() that needed full SessionState.
+ * Tracks per-agent: status, parent, pending tool call count, executing flag, mailbox counts.
+ */
+
+import type { AgentId } from '@roj-ai/sdk'
+import type { ProjectionEvent } from './events.js'
+import { toProtocolStatus } from './protocol-status.js'
+import type { AgentTreeNode } from './types.js'
+
+// ============================================================================
+// State
+// ============================================================================
+
+interface AgentTreeEntry {
+	id: AgentId
+	definitionName: string
+	status: 'pending' | 'inferring' | 'tool_exec' | 'errored' | 'paused'
+	parentId: AgentId | null
+	pendingToolCallCount: number
+	isExecuting: boolean
+	mailboxUnconsumedCount: number
+	cost: number
+}
+
+export interface AgentTreeProjectionState {
+	agents: Map<AgentId, AgentTreeEntry>
+}
+
+export function createAgentTreeProjectionState(): AgentTreeProjectionState {
+	return { agents: new Map() }
+}
+
+// ============================================================================
+// Reducer
+// ============================================================================
+
+export function applyEventToAgentTree(state: AgentTreeProjectionState, event: ProjectionEvent): AgentTreeProjectionState {
+	switch (event.type) {
+		case 'agent_spawned': {
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, {
+				id: event.agentId,
+				definitionName: event.definitionName,
+				status: 'pending',
+				parentId: event.parentId,
+				pendingToolCallCount: 0,
+				isExecuting: false,
+				mailboxUnconsumedCount: 0,
+				cost: 0,
+			})
+			return { ...state, agents: newAgents }
+		}
+
+		case 'agent_state_changed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, status: event.toState })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'inference_started': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, status: 'inferring' })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'inference_completed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const toolCallCount = event.response.toolCalls.length
+			const newAgents = new Map(state.agents)
+
+			// Decrement mailbox unconsumed count for consumed messages
+			let agents = newAgents
+			if (event.consumedMessageIds.length > 0) {
+				agents = decrementMailboxCounts(agents, event.agentId, event.consumedMessageIds.length)
+			}
+
+			agents.set(event.agentId, {
+				...agent,
+				status: toolCallCount > 0 ? 'tool_exec' : 'pending',
+				pendingToolCallCount: toolCallCount,
+				isExecuting: false,
+				cost: agent.cost + (event.metrics.cost ?? 0),
+			})
+
+			return { ...state, agents }
+		}
+
+		case 'inference_failed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, status: 'errored' })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'tool_started': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, isExecuting: true })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'tool_completed':
+		case 'tool_failed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const remaining = Math.max(0, agent.pendingToolCallCount - 1)
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, {
+				...agent,
+				pendingToolCallCount: remaining,
+				isExecuting: false,
+				status: remaining === 0 ? 'pending' : 'tool_exec',
+			})
+			return { ...state, agents: newAgents }
+		}
+
+		case 'agent_paused': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, status: 'paused' })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'agent_resumed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.agentId, { ...agent, status: 'pending' })
+			return { ...state, agents: newAgents }
+		}
+
+		case 'session_restarted': {
+			const newAgents = new Map(state.agents)
+			for (const [agentId, agent] of state.agents) {
+				let updated = agent
+				let changed = false
+
+				if (agent.status === 'inferring') {
+					updated = { ...updated, status: 'pending' as const }
+					changed = true
+				}
+				if (agent.isExecuting) {
+					updated = { ...updated, isExecuting: false }
+					changed = true
+				}
+
+				if (changed) {
+					newAgents.set(agentId, updated)
+				}
+			}
+			return { ...state, agents: newAgents }
+		}
+
+		case 'mailbox_message': {
+			const agent = state.agents.get(event.toAgentId)
+			if (!agent) return state
+			const newAgents = new Map(state.agents)
+			newAgents.set(event.toAgentId, {
+				...agent,
+				mailboxUnconsumedCount: agent.mailboxUnconsumedCount + 1,
+			})
+			return { ...state, agents: newAgents }
+		}
+
+		case 'mailbox_consumed': {
+			const agent = state.agents.get(event.agentId)
+			if (!agent) return state
+			return {
+				...state,
+				agents: decrementMailboxCounts(new Map(state.agents), event.agentId, event.messageIds.length),
+			}
+		}
+
+		default:
+			return state
+	}
+}
+
+function decrementMailboxCounts(agents: Map<AgentId, AgentTreeEntry>, agentId: AgentId, count: number): Map<AgentId, AgentTreeEntry> {
+	const agent = agents.get(agentId)
+	if (!agent) return agents
+	agents.set(agentId, {
+		...agent,
+		mailboxUnconsumedCount: Math.max(0, agent.mailboxUnconsumedCount - count),
+	})
+	return agents
+}
+
+// ============================================================================
+// Query
+// ============================================================================
+
+/**
+ * Build agent tree nodes from projection state.
+ */
+export function buildAgentTreeFromProjection(state: AgentTreeProjectionState): AgentTreeNode[] {
+	const allAgents = Array.from(state.agents.values())
+	const rootAgents = allAgents.filter((a) => a.parentId === null)
+	return rootAgents.map((agent) => buildTreeNode(state, agent))
+}
+
+function buildTreeNode(state: AgentTreeProjectionState, agent: AgentTreeEntry): AgentTreeNode {
+	const children = Array.from(state.agents.values())
+		.filter((a) => a.parentId === agent.id)
+		.map((child) => buildTreeNode(state, child))
+
+	return {
+		id: agent.id,
+		definitionName: agent.definitionName,
+		status: toProtocolStatus(agent.status),
+		parentId: agent.parentId,
+		children,
+		mailboxCount: agent.mailboxUnconsumedCount,
+		pendingToolCalls: agent.pendingToolCallCount,
+		isExecuting: agent.isExecuting,
+		cost: agent.cost,
+	}
+}

package/src/projections/chat-debug.ts

@@ -0,0 +1,260 @@
+/**
+ * Chat debug projection - tracks user-visible chat messages with debug links.
+ */
+
+import type { AgentId, LLMCallId, ToolCallId } from '@roj-ai/sdk'
+import type { AgentRegistryState } from './agent-registry.js'
+import type { ProjectionEvent } from './events.js'
+import type { DebugChatMessage } from './types.js'
+
+/**
+ * State for tracking chat messages with debug info.
+ */
+export interface ChatDebugState {
+	messages: DebugChatMessage[]
+	/** Tracking pending tool calls for linking (toolCallId -> { agentId, llmCallId, toolName }) */
+	pendingToolCalls: Map<ToolCallId, { agentId: AgentId; llmCallId?: LLMCallId; toolName: string }>
+	/** Last LLM call ID by agent (for linking tool calls to inference) */
+	lastLLMCallByAgent: Map<AgentId, LLMCallId>
+	/** Event index counter */
+	eventIndex: number
+}
+
+export function createChatDebugState(): ChatDebugState {
+	return {
+		messages: [],
+		pendingToolCalls: new Map(),
+		lastLLMCallByAgent: new Map(),
+		eventIndex: 0,
+	}
+}
+
+/**
+ * Apply event to chat debug state.
+ * @param registry Agent registry for name lookups
+ */
+export function applyEventToChatDebug(
+	state: ChatDebugState,
+	event: ProjectionEvent,
+	registry: AgentRegistryState,
+): ChatDebugState {
+	const currentIndex = state.eventIndex
+	const nextIndex = currentIndex + 1
+
+	const getAgentName = (agentId: AgentId): string => {
+		return registry.names.get(agentId) ?? 'unknown'
+	}
+
+	switch (event.type) {
+		case 'inference_completed': {
+			// Track the last LLM call for this agent
+			if (event.llmCallId) {
+				const newLastLLMCallByAgent = new Map(state.lastLLMCallByAgent)
+				newLastLLMCallByAgent.set(event.agentId, event.llmCallId)
+				return {
+					...state,
+					lastLLMCallByAgent: newLastLLMCallByAgent,
+					eventIndex: nextIndex,
+				}
+			}
+			return { ...state, eventIndex: nextIndex }
+		}
+
+		case 'tool_started': {
+			// Only track send_user_message and ask_user tools
+			if (event.toolName === 'send_user_message' || event.toolName === 'ask_user') {
+				const llmCallId = state.lastLLMCallByAgent.get(event.agentId)
+				const newPendingToolCalls = new Map(state.pendingToolCalls)
+				newPendingToolCalls.set(event.toolCallId, {
+					agentId: event.agentId,
+					llmCallId,
+					toolName: event.toolName,
+				})
+				return {
+					...state,
+					pendingToolCalls: newPendingToolCalls,
+					eventIndex: nextIndex,
+				}
+			}
+			return { ...state, eventIndex: nextIndex }
+		}
+
+		case 'user_message_sent': {
+			// Find the pending tool call for this message
+			let toolCallId: ToolCallId | undefined
+			let llmCallId: LLMCallId | undefined
+			let agentId: AgentId | undefined
+
+			// Look through pending tool calls to find a send_user_message from the same agent
+			for (const [tcId, info] of state.pendingToolCalls) {
+				if (info.toolName === 'send_user_message' && info.agentId === event.agentId) {
+					toolCallId = tcId
+					llmCallId = info.llmCallId
+					agentId = info.agentId
+					break
+				}
+			}
+
+			// Clean up the used pending tool call
+			const newPendingToolCalls = new Map(state.pendingToolCalls)
+			if (toolCallId) {
+				newPendingToolCalls.delete(toolCallId)
+			}
+
+			const newMessage: DebugChatMessage = {
+				type: 'agent_message',
+				messageId: event.messageId,
+				content: event.message,
+				timestamp: event.timestamp,
+				eventIndex: currentIndex,
+				agentId: agentId ?? event.agentId,
+				agentName: getAgentName(agentId ?? event.agentId),
+				llmCallId,
+				toolCallId,
+				format: event.format,
+			}
+
+			return {
+				...state,
+				messages: [...state.messages, newMessage],
+				pendingToolCalls: newPendingToolCalls,
+				eventIndex: nextIndex,
+			}
+		}
+
+		case 'user_question_asked': {
+			// Find the pending tool call for this question
+			let toolCallId: ToolCallId | undefined
+			let llmCallId: LLMCallId | undefined
+			let agentId: AgentId | undefined
+
+			// Look through pending tool calls to find an ask_user from the same agent
+			for (const [tcId, info] of state.pendingToolCalls) {
+				if (info.toolName === 'ask_user' && info.agentId === event.agentId) {
+					toolCallId = tcId
+					llmCallId = info.llmCallId
+					agentId = info.agentId
+					break
+				}
+			}
+
+			// Clean up the used pending tool call
+			const newPendingToolCalls = new Map(state.pendingToolCalls)
+			if (toolCallId) {
+				newPendingToolCalls.delete(toolCallId)
+			}
+
+			const newMessage: DebugChatMessage = {
+				type: 'ask_user',
+				messageId: event.messageId,
+				content: event.question,
+				timestamp: event.timestamp,
+				eventIndex: currentIndex,
+				agentId: agentId ?? event.agentId,
+				agentName: getAgentName(agentId ?? event.agentId),
+				llmCallId,
+				toolCallId,
+				inputType: event.inputType,
+				answered: false,
+			}
+
+			return {
+				...state,
+				messages: [...state.messages, newMessage],
+				pendingToolCalls: newPendingToolCalls,
+				eventIndex: nextIndex,
+			}
+		}
+
+		case 'user_chat_message_received': {
+			const newMessage: DebugChatMessage = {
+				type: 'user_message',
+				messageId: event.messageId,
+				content: event.content,
+				timestamp: event.timestamp,
+				eventIndex: currentIndex,
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+			}
+
+			return {
+				...state,
+				messages: [...state.messages, newMessage],
+				eventIndex: nextIndex,
+			}
+		}
+
+		case 'user_chat_answer_received': {
+			const updatedMessages = state.messages.map((msg) => {
+				if (msg.type === 'ask_user' && msg.messageId === event.questionId) {
+					return {
+						...msg,
+						answered: true,
+						answer: event.answerValue,
+					}
+				}
+				return msg
+			})
+
+			return {
+				...state,
+				messages: updatedMessages,
+				eventIndex: nextIndex,
+			}
+		}
+
+		case 'mailbox_message': {
+			// Only handle user messages (not answers to questions)
+			if (event.message.from === 'user' && !event.message.answerTo) {
+				const newMessage: DebugChatMessage = {
+					type: 'user_message',
+					messageId: event.message.id,
+					content: event.message.content,
+					timestamp: event.message.timestamp,
+					eventIndex: currentIndex,
+					agentId: event.toAgentId,
+					agentName: getAgentName(event.toAgentId),
+					mailboxMessageId: event.message.id,
+				}
+
+				return {
+					...state,
+					messages: [...state.messages, newMessage],
+					eventIndex: nextIndex,
+				}
+			}
+
+			// Handle answer to question - update the ask_user message
+			if (event.message.from === 'user' && event.message.answerTo) {
+				const updatedMessages = state.messages.map((msg) => {
+					if (msg.type === 'ask_user' && msg.messageId === event.message.answerTo) {
+						return {
+							...msg,
+							answered: true,
+							answer: event.message.answerValue,
+						}
+					}
+					return msg
+				})
+
+				return {
+					...state,
+					messages: updatedMessages,
+					eventIndex: nextIndex,
+				}
+			}
+
+			return { ...state, eventIndex: nextIndex }
+		}
+
+		default:
+			return { ...state, eventIndex: nextIndex }
+	}
+}
+
+/**
+ * Get chat debug messages sorted by timestamp.
+ */
+export function getChatDebugMessages(state: ChatDebugState): DebugChatMessage[] {
+	return state.messages
+}

package/src/projections/events.ts

@@ -0,0 +1,10 @@
+/**
+ * ProjectionEvent — union of all event types handled by shared projections.
+ *
+ * Boundary code (event-store.ts, debug.ts) casts DomainEvent → ProjectionEvent once.
+ * Individual projection reducers accept ProjectionEvent directly — no internal casts.
+ */
+
+import type { BuiltinEvent, ServiceStatusChangedEvent, SkillLoadedEvent } from '@roj-ai/sdk'
+
+export type ProjectionEvent = BuiltinEvent | SkillLoadedEvent | ServiceStatusChangedEvent

package/src/projections/index.ts

@@ -0,0 +1,59 @@
+// Projection event type
+export type { ProjectionEvent } from './events.js'
+
+// Types
+export type {
+	AgentTreeNode,
+	AssistantConversationMessageView,
+	ConversationMessageView,
+	DebugChatMessage,
+	GetAgentDetailResponse,
+	GetEventsResponse,
+	GetMetricsResponse,
+	GlobalMailboxMessage,
+	MailboxMessageView,
+	SystemConversationMessageView,
+	TimelineItem,
+	ToolCallView,
+	ToolConversationMessageView,
+	UserConversationMessageView,
+} from './types.js'
+
+// Protocol status
+export { toProtocolStatus } from './protocol-status.js'
+
+// Agent registry
+export type { AgentRegistryState } from './agent-registry.js'
+export { applyEventToAgentRegistry, createAgentRegistryState, getAgentName } from './agent-registry.js'
+
+// Agent tree projection (self-contained — no SessionState)
+export type { AgentTreeProjectionState } from './agent-tree-projection.js'
+export { applyEventToAgentTree, buildAgentTreeFromProjection, createAgentTreeProjectionState } from './agent-tree-projection.js'
+
+// Metrics
+export type { MetricsState } from './metrics.js'
+export { applyEventToMetrics, createMetricsState, metricsStateToResponse } from './metrics.js'
+
+// Timeline
+export type { TimelineState } from './timeline.js'
+export { applyEventToTimeline, createTimelineState, getTimelineItems } from './timeline.js'
+
+// Mailbox projection
+export type { MailboxState } from './mailbox.js'
+export { applyEventToMailbox, createMailboxState, getMailboxMessages } from './mailbox.js'
+
+// Chat debug
+export type { ChatDebugState } from './chat-debug.js'
+export { applyEventToChatDebug, createChatDebugState, getChatDebugMessages } from './chat-debug.js'
+
+// Agent detail projection (self-contained — no SessionState)
+export type { AgentDetailProjectionState } from './agent-detail-projection.js'
+export { applyEventToAgentDetail, createAgentDetailProjectionState, getAgentDetail } from './agent-detail-projection.js'
+
+// Session info projection
+export type { SessionInfoState } from './session-info.js'
+export { applyEventToSessionInfo, createSessionInfoState } from './session-info.js'
+
+// Services projection
+export type { ServiceEntry, ServicesProjectionState, ServiceStatus } from './services-projection.js'
+export { applyEventToServices, createServicesProjectionState } from './services-projection.js'

package/src/projections/mailbox.ts

@@ -0,0 +1,113 @@
+/**
+ * Global mailbox projection - tracks all inter-agent messages.
+ */
+
+import type { AgentId } from '@roj-ai/sdk'
+import type { AgentRegistryState } from './agent-registry.js'
+import type { ProjectionEvent } from './events.js'
+import type { GlobalMailboxMessage } from './types.js'
+
+export interface MailboxState {
+	messages: GlobalMailboxMessage[]
+	consumedIds: Set<string>
+}
+
+export function createMailboxState(): MailboxState {
+	return {
+		messages: [],
+		consumedIds: new Set(),
+	}
+}
+
+/**
+ * Apply event to mailbox state.
+ * @param registry Agent registry for name lookups
+ */
+export function applyEventToMailbox(
+	state: MailboxState,
+	event: ProjectionEvent,
+	registry: AgentRegistryState,
+): MailboxState {
+	switch (event.type) {
+		case 'mailbox_message': {
+			const msg = event.message
+
+			// Determine from agent name
+			let fromAgentId: string
+			let fromAgentName: string
+
+			if (msg.from === 'user') {
+				fromAgentId = 'user'
+				fromAgentName = 'User'
+			} else if (msg.from === 'orchestrator' || msg.from === 'communicator') {
+				fromAgentId = msg.from
+				fromAgentName = msg.from.charAt(0).toUpperCase() + msg.from.slice(1)
+			} else {
+				fromAgentId = msg.from
+				fromAgentName = registry.names.get(msg.from as AgentId) ?? 'unknown'
+			}
+
+			const newMessage: GlobalMailboxMessage = {
+				id: msg.id,
+				fromAgentId,
+				fromAgentName,
+				toAgentId: event.toAgentId,
+				toAgentName: registry.names.get(event.toAgentId) ?? 'unknown',
+				content: msg.content,
+				timestamp: msg.timestamp,
+				consumed: state.consumedIds.has(msg.id),
+			}
+
+			return {
+				...state,
+				messages: [...state.messages, newMessage],
+			}
+		}
+
+		case 'mailbox_consumed': {
+			const newConsumedIds = new Set(state.consumedIds)
+			for (const msgId of event.messageIds) {
+				newConsumedIds.add(msgId)
+			}
+
+			// Update consumed status in existing messages
+			const consumedSet = new Set(event.messageIds as string[])
+			const updatedMessages = state.messages.map((m) => consumedSet.has(m.id) ? { ...m, consumed: true } : m)
+
+			return {
+				messages: updatedMessages,
+				consumedIds: newConsumedIds,
+			}
+		}
+
+		case 'inference_completed': {
+			// inference_completed also marks messages as consumed
+			if (event.consumedMessageIds.length === 0) return state
+
+			const newConsumedIds = new Set(state.consumedIds)
+			for (const msgId of event.consumedMessageIds) {
+				newConsumedIds.add(msgId)
+			}
+
+			// Update consumed status in existing messages
+			const consumedSet = new Set(event.consumedMessageIds as string[])
+			const updatedMessages = state.messages.map((m) => consumedSet.has(m.id) ? { ...m, consumed: true } : m)
+
+			return {
+				messages: updatedMessages,
+				consumedIds: newConsumedIds,
+			}
+		}
+
+		default:
+			return state
+	}
+}
+
+/**
+ * Get mailbox messages sorted by timestamp.
+ */
+export function getMailboxMessages(state: MailboxState): GlobalMailboxMessage[] {
+	// Messages are already in order since we append them
+	return state.messages
+}