feat(web): sessionReducer pure delta-application with vm_seq watermark

Author: aksOps

web/src/state/sessionReducer.ts

@@ -0,0 +1,104 @@
+import type {
+  Session, AgentRun, ToolCall, AgentDefinition,
+  SessionEvent, SessionFullBundle,
+} from '@/api/types';
+
+export interface SessionState {
+  session: Session | null;
+  agentsRun: AgentRun[];
+  toolCalls: ToolCall[];
+  events: SessionEvent[];
+  agentDefinitions: Record<string, AgentDefinition>;
+  vmSeq: number;
+}
+
+export const initialSessionState: SessionState = {
+  session: null,
+  agentsRun: [],
+  toolCalls: [],
+  events: [],
+  agentDefinitions: {},
+  vmSeq: 0,
+};
+
+type Action =
+  | { type: 'bootstrap'; bundle: SessionFullBundle }
+  | { type: 'event'; event: SessionEvent };
+
+export function sessionReducer(state: SessionState, action: Action): SessionState {
+  switch (action.type) {
+    case 'bootstrap':
+      return {
+        session: action.bundle.session,
+        agentsRun: action.bundle.agents_run,
+        toolCalls: action.bundle.tool_calls,
+        events: action.bundle.events,
+        agentDefinitions: action.bundle.agent_definitions,
+        vmSeq: action.bundle.vm_seq,
+      };
+
+    case 'event': {
+      const ev = action.event;
+      if (ev.seq <= state.vmSeq) return state;  // drop dupes / out-of-order
+      const events = [...state.events, ev];
+      let session = state.session;
+      let agentsRun = state.agentsRun;
+      let toolCalls = state.toolCalls;
+
+      switch (ev.kind) {
+        case 'agent_finished': {
+          const p = ev.payload as Partial<AgentRun>;
+          agentsRun = [...agentsRun, {
+            agent: p.agent ?? '',
+            started_at: p.started_at ?? '',
+            ended_at: p.ended_at ?? ev.ts,
+            summary: p.summary ?? '',
+            confidence: p.confidence ?? null,
+            confidence_rationale: p.confidence_rationale ?? null,
+            signal: p.signal ?? null,
+          }];
+          break;
+        }
+        case 'tool_invoked': {
+          const p = ev.payload as Partial<ToolCall>;
+          toolCalls = [...toolCalls, {
+            agent: p.agent ?? '',
+            tool: p.tool ?? '',
+            args: p.args ?? {},
+            result: p.result ?? null,
+            ts: ev.ts,
+            risk: p.risk ?? null,
+            status: 'executed',
+            approver: null,
+            approved_at: null,
+            approval_rationale: null,
+          }];
+          break;
+        }
+        case 'approval_pending': {
+          const p = ev.payload as Partial<ToolCall>;
+          toolCalls = [...toolCalls, {
+            agent: p.agent ?? '',
+            tool: p.tool ?? '',
+            args: p.args ?? {},
+            result: null,
+            ts: ev.ts,
+            risk: p.risk ?? null,
+            status: 'pending_approval',
+            approver: null,
+            approved_at: null,
+            approval_rationale: null,
+          }];
+          break;
+        }
+        case 'status_changed': {
+          const p = ev.payload as { status?: Session['status'] };
+          if (session && p.status) session = { ...session, status: p.status };
+          break;
+        }
+      }
+
+      return { ...state, events, session, agentsRun, toolCalls, vmSeq: ev.seq };
+    }
+  }
+}

web/tests/unit/sessionReducer.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { sessionReducer, initialSessionState } from '@/state/sessionReducer';
+import type { SessionFullBundle, SessionEvent } from '@/api/types';
+
+const baseBundle: SessionFullBundle = {
+  session: {
+    id: 'SES-1', status: 'in_progress',
+    created_at: 'x', updated_at: 'x', deleted_at: null,
+    agents_run: [], tool_calls: [], findings: {},
+    pending_intervention: null, user_inputs: [],
+    parent_session_id: null, dedup_rationale: null,
+    extra_fields: {}, version: 1,
+  },
+  agents_run: [],
+  tool_calls: [],
+  events: [],
+  agent_definitions: {},
+  vm_seq: 0,
+};
+
+describe('sessionReducer', () => {
+  describe('action: bootstrap', () => {
+    it('replaces full state with bundle', () => {
+      const next = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      expect(next.vmSeq).toBe(0);
+      expect(next.session?.id).toBe('SES-1');
+    });
+  });
+
+  describe('action: event', () => {
+    it('drops events with seq <= vmSeq (idempotent)', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: { ...baseBundle, vm_seq: 5 } });
+      const stale: SessionEvent = { seq: 3, kind: 'agent_started', payload: {}, ts: 'x' };
+      const next = sessionReducer(state, { type: 'event', event: stale });
+      expect(next).toBe(state);  // no change
+    });
+
+    it('appends events with seq > vmSeq and bumps vmSeq', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      const fresh: SessionEvent = { seq: 1, kind: 'agent_started', payload: { agent: 'intake' }, ts: 'x' };
+      const next = sessionReducer(state, { type: 'event', event: fresh });
+      expect(next.vmSeq).toBe(1);
+      expect(next.events).toHaveLength(1);
+    });
+
+    it('event "agent_finished" appends an AgentRun', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      const finished: SessionEvent = {
+        seq: 1, kind: 'agent_finished', ts: 'x',
+        payload: { agent: 'intake', summary: 'done', confidence: 0.9 },
+      };
+      const next = sessionReducer(state, { type: 'event', event: finished });
+      expect(next.agentsRun).toHaveLength(1);
+      expect(next.agentsRun[0]?.agent).toBe('intake');
+    });
+
+    it('event "tool_invoked" appends a ToolCall with status="executed"', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      const tool: SessionEvent = {
+        seq: 1, kind: 'tool_invoked', ts: 'x',
+        payload: { agent: 'triage', tool: 'obs:get_logs', args: {}, result: 'ok' },
+      };
+      const next = sessionReducer(state, { type: 'event', event: tool });
+      expect(next.toolCalls).toHaveLength(1);
+      expect(next.toolCalls[0]?.status).toBe('executed');
+    });
+
+    it('event "approval_pending" inserts a pending tool call', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      const ev: SessionEvent = {
+        seq: 1, kind: 'approval_pending', ts: 'x',
+        payload: { agent: 'investigate', tool: 'rem:propose_fix', args: {}, risk: 'high' },
+      };
+      const next = sessionReducer(state, { type: 'event', event: ev });
+      expect(next.toolCalls[0]?.status).toBe('pending_approval');
+      expect(next.toolCalls[0]?.risk).toBe('high');
+    });
+
+    it('event "status_changed" updates session.status', () => {
+      const state = sessionReducer(initialSessionState, { type: 'bootstrap', bundle: baseBundle });
+      const ev: SessionEvent = {
+        seq: 1, kind: 'status_changed', ts: 'x',
+        payload: { status: 'resolved' },
+      };
+      const next = sessionReducer(state, { type: 'event', event: ev });
+      expect(next.session?.status).toBe('resolved');
+    });
+  });
+});