@roj-ai/shared 0.0.2

package/src/projections/metrics.ts

@@ -0,0 +1,111 @@
+/**
+ * Metrics projection - tracks token usage, costs, and call counts.
+ */
+
+import type { ProjectionEvent } from './events.js'
+import type { GetMetricsResponse } from './types.js'
+
+export interface ProviderMetricsState {
+	llmCalls: number
+	totalTokens: number
+	promptTokens: number
+	completionTokens: number
+	totalCost: number
+}
+
+export interface MetricsState {
+	totalTokens: number
+	promptTokens: number
+	completionTokens: number
+	llmCalls: number
+	toolCalls: number
+	totalCost: number
+	firstEventTimestamp: number | null
+	lastEventTimestamp: number | null
+	byProvider: Record<string, ProviderMetricsState>
+}
+
+export function createMetricsState(): MetricsState {
+	return {
+		totalTokens: 0,
+		promptTokens: 0,
+		completionTokens: 0,
+		llmCalls: 0,
+		toolCalls: 0,
+		totalCost: 0,
+		firstEventTimestamp: null,
+		lastEventTimestamp: null,
+		byProvider: {},
+	}
+}
+
+export function applyEventToMetrics(state: MetricsState, event: ProjectionEvent): MetricsState {
+	// Update timestamps
+	const firstEventTimestamp = state.firstEventTimestamp ?? event.timestamp
+	const lastEventTimestamp = event.timestamp
+
+	switch (event.type) {
+		case 'inference_completed': {
+			const provider = event.metrics.provider
+			const byProvider = provider
+				? {
+					...state.byProvider,
+					[provider]: {
+						llmCalls: (state.byProvider[provider]?.llmCalls ?? 0) + 1,
+						totalTokens: (state.byProvider[provider]?.totalTokens ?? 0) + event.metrics.totalTokens,
+						promptTokens: (state.byProvider[provider]?.promptTokens ?? 0) + event.metrics.promptTokens,
+						completionTokens: (state.byProvider[provider]?.completionTokens ?? 0) + event.metrics.completionTokens,
+						totalCost: (state.byProvider[provider]?.totalCost ?? 0) + (event.metrics.cost ?? 0),
+					},
+				}
+				: state.byProvider
+			return {
+				...state,
+				llmCalls: state.llmCalls + 1,
+				promptTokens: state.promptTokens + event.metrics.promptTokens,
+				completionTokens: state.completionTokens + event.metrics.completionTokens,
+				totalTokens: state.totalTokens + event.metrics.totalTokens,
+				totalCost: state.totalCost + (event.metrics.cost ?? 0),
+				firstEventTimestamp,
+				lastEventTimestamp,
+				byProvider,
+			}
+		}
+
+		case 'tool_started':
+			return {
+				...state,
+				toolCalls: state.toolCalls + 1,
+				firstEventTimestamp,
+				lastEventTimestamp,
+			}
+
+		default:
+			// Only update timestamps for other events
+			if (state.firstEventTimestamp !== firstEventTimestamp || state.lastEventTimestamp !== lastEventTimestamp) {
+				return { ...state, firstEventTimestamp, lastEventTimestamp }
+			}
+			return state
+	}
+}
+
+/**
+ * Convert MetricsState to GetMetricsResponse format.
+ */
+export function metricsStateToResponse(state: MetricsState, agentCount: number): GetMetricsResponse {
+	const durationMs = state.firstEventTimestamp && state.lastEventTimestamp
+		? state.lastEventTimestamp - state.firstEventTimestamp
+		: 0
+
+	return {
+		totalTokens: state.totalTokens,
+		promptTokens: state.promptTokens,
+		completionTokens: state.completionTokens,
+		totalCost: state.totalCost > 0 ? state.totalCost : undefined,
+		llmCalls: state.llmCalls,
+		toolCalls: state.toolCalls,
+		agentCount,
+		durationMs,
+		byProvider: state.byProvider,
+	}
+}

package/src/projections/protocol-status.ts

@@ -0,0 +1,23 @@
+/**
+ * Protocol status conversion.
+ */
+
+import type { DomainAgentStatus, ProtocolAgentStatus } from '@roj-ai/sdk'
+
+/**
+ * Convert domain AgentStatus to protocol AgentStatus.
+ */
+export function toProtocolStatus(status: DomainAgentStatus): ProtocolAgentStatus {
+	switch (status) {
+		case 'pending':
+			return 'idle'
+		case 'inferring':
+			return 'thinking'
+		case 'tool_exec':
+			return 'responding'
+		case 'errored':
+			return 'error'
+		case 'paused':
+			return 'paused'
+	}
+}

package/src/projections/services-projection.ts

@@ -0,0 +1,89 @@
+/**
+ * Services projection - tracks service states from events.
+ *
+ * Replaces selectPluginState(sessionState, 'services') for client-side use.
+ * Handles service_status_changed and session_restarted events.
+ */
+
+import type { ServiceStatus } from '@roj-ai/sdk'
+export type { ServiceStatus } from '@roj-ai/sdk'
+import type { ProjectionEvent } from './events.js'
+
+export interface ServiceEntry {
+	serviceType: string
+	status: ServiceStatus
+	port?: number
+	error?: string
+	startedAt?: number
+	readyAt?: number
+	stoppedAt?: number
+}
+
+export interface ServicesProjectionState {
+	services: Map<string, ServiceEntry>
+}
+
+export function createServicesProjectionState(): ServicesProjectionState {
+	return { services: new Map() }
+}
+
+export function applyEventToServices(state: ServicesProjectionState, event: ProjectionEvent): ServicesProjectionState {
+	switch (event.type) {
+		case 'service_status_changed': {
+			const newServices = new Map(state.services)
+			const existing = newServices.get(event.serviceType)
+
+			if (!existing && event.toStatus === 'starting') {
+				newServices.set(event.serviceType, {
+					serviceType: event.serviceType,
+					status: event.toStatus,
+					startedAt: event.timestamp,
+				})
+			} else if (existing) {
+				const updated: ServiceEntry = {
+					...existing,
+					status: event.toStatus,
+				}
+				if (event.toStatus === 'starting') {
+					updated.startedAt = event.timestamp
+					updated.error = undefined
+				}
+				if (event.toStatus === 'ready') {
+					updated.readyAt = event.timestamp
+					if (event.port !== undefined) {
+						updated.port = event.port
+					}
+				}
+				if (event.toStatus === 'failed' && event.error) {
+					updated.error = event.error
+				}
+				if (event.toStatus === 'stopped') {
+					updated.stoppedAt = event.timestamp
+				}
+				newServices.set(event.serviceType, updated)
+			}
+
+			return { ...state, services: newServices }
+		}
+
+		case 'session_restarted': {
+			let changed = false
+			const newServices = new Map(state.services)
+			for (const [serviceType, entry] of state.services) {
+				if (entry.status === 'starting' || entry.status === 'ready') {
+					newServices.set(serviceType, {
+						...entry,
+						status: 'stopped',
+						port: undefined,
+						stoppedAt: event.timestamp,
+					})
+					changed = true
+				}
+			}
+			return changed ? { ...state, services: newServices } : state
+		}
+
+		default:
+			return state
+	}
+}

package/src/projections/session-info.ts

@@ -0,0 +1,47 @@
+/**
+ * Session info projection - tracks basic session metadata.
+ *
+ * Extracts session-level information (id, preset, status, timestamps)
+ * from lifecycle events without requiring full SessionState.
+ */
+
+import type { SessionId } from '@roj-ai/sdk'
+import type { ProjectionEvent } from './events.js'
+
+export interface SessionInfoState {
+	id: SessionId | null
+	presetId: string | null
+	status: 'active' | 'closed'
+	createdAt: number | null
+	closedAt?: number
+	workspaceDir?: string
+}
+
+export function createSessionInfoState(): SessionInfoState {
+	return {
+		id: null,
+		presetId: null,
+		status: 'active',
+		createdAt: null,
+	}
+}
+
+export function applyEventToSessionInfo(state: SessionInfoState, event: ProjectionEvent): SessionInfoState {
+	switch (event.type) {
+		case 'session_created': {
+			return {
+				...state,
+				id: event.sessionId,
+				presetId: event.presetId,
+				createdAt: event.timestamp,
+				workspaceDir: event.workspaceDir,
+			}
+		}
+		case 'session_closed':
+			return { ...state, status: 'closed', closedAt: event.timestamp }
+		case 'session_reopened':
+			return { ...state, status: 'active', closedAt: undefined }
+		default:
+			return state
+	}
+}

package/src/projections/timeline.ts

@@ -0,0 +1,228 @@
+/**
+ * Timeline projection - tracks LLM calls, tool executions, and compactions.
+ */
+
+import type { AgentId, InferenceStartedEvent, LLMCallLogEntry, ToolCallId, ToolStartedEvent } from '@roj-ai/sdk'
+import type { AgentRegistryState } from './agent-registry.js'
+import type { ProjectionEvent } from './events.js'
+import type { TimelineItem } from './types.js'
+
+export interface TimelineState {
+	items: TimelineItem[]
+	/** Pending inference starts waiting for completion */
+	pendingInferences: Map<string, InferenceStartedEvent>
+	/** Pending tool starts waiting for completion */
+	pendingTools: Map<string, ToolStartedEvent>
+}
+
+export function createTimelineState(): TimelineState {
+	return {
+		items: [],
+		pendingInferences: new Map(),
+		pendingTools: new Map(),
+	}
+}
+
+/**
+ * Apply event to timeline state.
+ * @param registry Agent registry for name lookups
+ * @param llmCallMap Optional map for enriching LLM calls with detailed metrics
+ */
+export function applyEventToTimeline(
+	state: TimelineState,
+	event: ProjectionEvent,
+	registry: AgentRegistryState,
+	llmCallMap?: Map<string, LLMCallLogEntry>,
+): TimelineState {
+	const getAgentName = (agentId: string): string => {
+		return registry.names.get(agentId as AgentId) ?? 'unknown'
+	}
+
+	switch (event.type) {
+		case 'inference_started': {
+			const newPending = new Map(state.pendingInferences)
+			newPending.set(event.agentId, event)
+			return { ...state, pendingInferences: newPending }
+		}
+
+		case 'inference_completed': {
+			const startEvent = state.pendingInferences.get(event.agentId)
+			const newPending = new Map(state.pendingInferences)
+			newPending.delete(event.agentId)
+
+			const llmCall = event.llmCallId && llmCallMap ? llmCallMap.get(event.llmCallId) : undefined
+			const metrics = llmCall?.metrics ?? event.metrics
+
+			const newItem: TimelineItem = {
+				id: event.llmCallId ?? `llm-${event.agentId}-${event.timestamp}`,
+				type: 'llm',
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+				startedAt: startEvent?.timestamp ?? event.timestamp,
+				completedAt: event.timestamp,
+				durationMs: startEvent ? event.timestamp - startEvent.timestamp : undefined,
+				status: 'success',
+				model: event.metrics.model,
+				promptTokens: metrics.promptTokens,
+				completionTokens: metrics.completionTokens,
+				cachedTokens: metrics.cachedTokens,
+				cacheWriteTokens: metrics.cacheWriteTokens,
+				cost: metrics.cost,
+				llmCallId: event.llmCallId,
+			}
+
+			return {
+				...state,
+				items: [...state.items, newItem],
+				pendingInferences: newPending,
+			}
+		}
+
+		case 'inference_failed': {
+			const startEvent = state.pendingInferences.get(event.agentId)
+			const newPending = new Map(state.pendingInferences)
+			newPending.delete(event.agentId)
+
+			const newItem: TimelineItem = {
+				id: event.llmCallId ?? `llm-${event.agentId}-${event.timestamp}`,
+				type: 'llm',
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+				startedAt: startEvent?.timestamp ?? event.timestamp,
+				completedAt: event.timestamp,
+				durationMs: startEvent ? event.timestamp - startEvent.timestamp : undefined,
+				status: 'error',
+				error: event.error,
+				llmCallId: event.llmCallId,
+			}
+
+			return {
+				...state,
+				items: [...state.items, newItem],
+				pendingInferences: newPending,
+			}
+		}
+
+		case 'tool_started': {
+			const newPending = new Map(state.pendingTools)
+			newPending.set(event.toolCallId, event)
+			return { ...state, pendingTools: newPending }
+		}
+
+		case 'tool_completed': {
+			const startEvent = state.pendingTools.get(event.toolCallId)
+			const newPending = new Map(state.pendingTools)
+			newPending.delete(event.toolCallId)
+
+			const newItem: TimelineItem = {
+				id: event.toolCallId,
+				type: 'tool',
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+				startedAt: startEvent?.timestamp ?? event.timestamp,
+				completedAt: event.timestamp,
+				durationMs: startEvent ? event.timestamp - startEvent.timestamp : undefined,
+				status: 'success',
+				toolName: startEvent?.toolName,
+				toolCallId: event.toolCallId,
+				toolInput: startEvent?.input,
+				toolResult: event.result,
+			}
+
+			return {
+				...state,
+				items: [...state.items, newItem],
+				pendingTools: newPending,
+			}
+		}
+
+		case 'tool_failed': {
+			const startEvent = state.pendingTools.get(event.toolCallId)
+			const newPending = new Map(state.pendingTools)
+			newPending.delete(event.toolCallId)
+
+			const newItem: TimelineItem = {
+				id: event.toolCallId,
+				type: 'tool',
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+				startedAt: startEvent?.timestamp ?? event.timestamp,
+				completedAt: event.timestamp,
+				durationMs: startEvent ? event.timestamp - startEvent.timestamp : undefined,
+				status: 'error',
+				toolName: startEvent?.toolName,
+				toolCallId: event.toolCallId,
+				toolInput: startEvent?.input,
+				error: event.error,
+			}
+
+			return {
+				...state,
+				items: [...state.items, newItem],
+				pendingTools: newPending,
+			}
+		}
+
+		case 'context_compacted': {
+			const newItem: TimelineItem = {
+				id: `compaction-${event.agentId}-${event.timestamp}`,
+				type: 'compaction',
+				agentId: event.agentId,
+				agentName: getAgentName(event.agentId),
+				startedAt: event.timestamp,
+				completedAt: event.timestamp,
+				status: 'success',
+				originalTokens: event.originalTokens,
+				compactedTokens: event.compactedTokens,
+				messagesRemoved: event.messagesRemoved,
+			}
+
+			return {
+				...state,
+				items: [...state.items, newItem],
+			}
+		}
+
+		default:
+			return state
+	}
+}
+
+/**
+ * Get timeline items including running items from pending state.
+ */
+export function getTimelineItems(state: TimelineState, registry: AgentRegistryState): TimelineItem[] {
+	const items = [...state.items]
+
+	// Add running items for pending inferences
+	for (const [agentId, startEvent] of state.pendingInferences) {
+		items.push({
+			id: `llm-running-${agentId}-${startEvent.timestamp}`,
+			type: 'llm',
+			agentId: agentId as AgentId,
+			agentName: registry.names.get(agentId as AgentId) ?? 'unknown',
+			startedAt: startEvent.timestamp,
+			status: 'running',
+		})
+	}
+
+	// Add running items for pending tools
+	for (const [toolCallId, startEvent] of state.pendingTools) {
+		items.push({
+			id: toolCallId,
+			type: 'tool',
+			agentId: startEvent.agentId,
+			agentName: registry.names.get(startEvent.agentId) ?? 'unknown',
+			startedAt: startEvent.timestamp,
+			status: 'running',
+			toolName: startEvent.toolName,
+			toolCallId: toolCallId as ToolCallId,
+			toolInput: startEvent.input,
+		})
+	}
+
+	// Sort by startedAt
+	items.sort((a, b) => a.startedAt - b.startedAt)
+
+	return items
+}