agent-relay 2.0.29 → 2.0.32

package/packages/api-types/src/schemas/decision.test.ts

@@ -0,0 +1,324 @@
+/**
+ * Decision Schema Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  DecisionUrgencySchema,
+  DecisionCategorySchema,
+  DecisionOptionSchema,
+  ApiDecisionSchema,
+  DecisionSchema,
+  PendingDecisionSchema,
+  TrajectoryDecisionTypeSchema,
+  TrajectoryDecisionOutcomeSchema,
+  TrajectoryDecisionSchema,
+  TrajectorySchema,
+} from './decision.js';
+
+describe('Decision Schemas', () => {
+  describe('DecisionUrgencySchema', () => {
+    it('should validate urgency levels', () => {
+      expect(DecisionUrgencySchema.parse('low')).toBe('low');
+      expect(DecisionUrgencySchema.parse('medium')).toBe('medium');
+      expect(DecisionUrgencySchema.parse('high')).toBe('high');
+      expect(DecisionUrgencySchema.parse('critical')).toBe('critical');
+    });
+
+    it('should reject invalid urgency', () => {
+      expect(() => DecisionUrgencySchema.parse('urgent')).toThrow();
+      expect(() => DecisionUrgencySchema.parse('P1')).toThrow();
+    });
+  });
+
+  describe('DecisionCategorySchema', () => {
+    it('should validate categories', () => {
+      expect(DecisionCategorySchema.parse('approval')).toBe('approval');
+      expect(DecisionCategorySchema.parse('choice')).toBe('choice');
+      expect(DecisionCategorySchema.parse('input')).toBe('input');
+      expect(DecisionCategorySchema.parse('confirmation')).toBe('confirmation');
+    });
+
+    it('should reject invalid category', () => {
+      expect(() => DecisionCategorySchema.parse('question')).toThrow();
+    });
+  });
+
+  describe('DecisionOptionSchema', () => {
+    it('should validate option with description', () => {
+      const option = {
+        id: 'opt-1',
+        label: 'Option A',
+        description: 'This is option A',
+      };
+      const result = DecisionOptionSchema.parse(option);
+      expect(result.id).toBe('opt-1');
+      expect(result.label).toBe('Option A');
+    });
+
+    it('should allow option without description', () => {
+      const option = {
+        id: 'opt-2',
+        label: 'Option B',
+      };
+      const result = DecisionOptionSchema.parse(option);
+      expect(result.description).toBeUndefined();
+    });
+  });
+
+  describe('ApiDecisionSchema', () => {
+    it('should validate complete API decision', () => {
+      const decision = {
+        id: 'dec-001',
+        agentName: 'FullStack',
+        title: 'Choose database',
+        description: 'Select the database to use for the project',
+        options: [
+          { id: 'opt-1', label: 'PostgreSQL', description: 'Relational DB' },
+          { id: 'opt-2', label: 'MongoDB', description: 'Document DB' },
+        ],
+        urgency: 'high',
+        category: 'choice',
+        createdAt: '2025-01-22T10:00:00Z',
+        expiresAt: '2025-01-22T12:00:00Z',
+        context: { projectType: 'web-app' },
+      };
+      const result = ApiDecisionSchema.parse(decision);
+      expect(result.options).toHaveLength(2);
+      expect(result.urgency).toBe('high');
+      expect(result.category).toBe('choice');
+    });
+
+    it('should allow decision without options', () => {
+      const decision = {
+        id: 'dec-002',
+        agentName: 'Worker',
+        title: 'Approve deployment',
+        description: 'Approve the deployment to production',
+        urgency: 'critical',
+        category: 'approval',
+        createdAt: '2025-01-22T11:00:00Z',
+      };
+      const result = ApiDecisionSchema.parse(decision);
+      expect(result.options).toBeUndefined();
+      expect(result.expiresAt).toBeUndefined();
+    });
+  });
+
+  describe('DecisionSchema', () => {
+    it('should validate decision with string timestamp', () => {
+      const decision = {
+        id: 'dec-003',
+        agentName: 'Backend',
+        timestamp: '2025-01-22T10:30:00Z',
+        type: 'input',
+        title: 'Enter API key',
+        description: 'Provide the third-party API key',
+        priority: 'medium',
+      };
+      const result = DecisionSchema.parse(decision);
+      expect(result.timestamp).toBe('2025-01-22T10:30:00Z');
+    });
+
+    it('should validate decision with numeric timestamp', () => {
+      const decision = {
+        id: 'dec-004',
+        agentName: 'Frontend',
+        timestamp: 1705920600000,
+        type: 'confirmation',
+        title: 'Confirm delete',
+        description: 'Are you sure you want to delete this file?',
+        priority: 'low',
+      };
+      const result = DecisionSchema.parse(decision);
+      expect(result.timestamp).toBe(1705920600000);
+    });
+
+    it('should validate decision with options and context', () => {
+      const decision = {
+        id: 'dec-005',
+        agentName: 'Lead',
+        timestamp: Date.now(),
+        type: 'choice',
+        title: 'Select framework',
+        description: 'Choose the frontend framework',
+        options: [
+          { id: 'react', label: 'React' },
+          { id: 'vue', label: 'Vue' },
+        ],
+        priority: 'high',
+        context: { team: 'frontend' },
+        expiresAt: '2025-01-23T10:00:00Z',
+      };
+      const result = DecisionSchema.parse(decision);
+      expect(result.options).toHaveLength(2);
+      expect(result.context).toEqual({ team: 'frontend' });
+    });
+  });
+
+  describe('PendingDecisionSchema', () => {
+    it('should validate pending decision', () => {
+      const decision = {
+        id: 'pending-001',
+        agent: 'Worker',
+        question: 'Which approach should we use?',
+        options: ['Approach A', 'Approach B', 'Approach C'],
+        context: 'Building new feature',
+        priority: 'medium',
+        createdAt: '2025-01-22T09:00:00Z',
+        expiresAt: '2025-01-22T17:00:00Z',
+      };
+      const result = PendingDecisionSchema.parse(decision);
+      expect(result.options).toHaveLength(3);
+      expect(result.priority).toBe('medium');
+    });
+
+    it('should allow pending decision without options', () => {
+      const decision = {
+        id: 'pending-002',
+        agent: 'Backend',
+        question: 'What is the expected response format?',
+        priority: 'low',
+        createdAt: '2025-01-22T10:00:00Z',
+      };
+      const result = PendingDecisionSchema.parse(decision);
+      expect(result.options).toBeUndefined();
+      expect(result.context).toBeUndefined();
+    });
+  });
+
+  describe('TrajectoryDecisionTypeSchema', () => {
+    it('should validate decision types', () => {
+      expect(TrajectoryDecisionTypeSchema.parse('tool_call')).toBe('tool_call');
+      expect(TrajectoryDecisionTypeSchema.parse('message')).toBe('message');
+      expect(TrajectoryDecisionTypeSchema.parse('file_edit')).toBe('file_edit');
+      expect(TrajectoryDecisionTypeSchema.parse('command')).toBe('command');
+      expect(TrajectoryDecisionTypeSchema.parse('question')).toBe('question');
+    });
+  });
+
+  describe('TrajectoryDecisionOutcomeSchema', () => {
+    it('should validate outcomes', () => {
+      expect(TrajectoryDecisionOutcomeSchema.parse('success')).toBe('success');
+      expect(TrajectoryDecisionOutcomeSchema.parse('error')).toBe('error');
+      expect(TrajectoryDecisionOutcomeSchema.parse('pending')).toBe('pending');
+    });
+  });
+
+  describe('TrajectoryDecisionSchema', () => {
+    it('should validate simple trajectory decision', () => {
+      const decision = {
+        id: 'traj-001',
+        timestamp: '2025-01-22T10:00:00Z',
+        agent: 'FullStack',
+        type: 'tool_call',
+        summary: 'Read file package.json',
+        details: 'Reading package.json to check dependencies',
+        outcome: 'success',
+      };
+      const result = TrajectoryDecisionSchema.parse(decision);
+      expect(result.id).toBe('traj-001');
+      expect(result.type).toBe('tool_call');
+      expect(result.outcome).toBe('success');
+    });
+
+    it('should validate trajectory decision with children (recursive)', () => {
+      const decision = {
+        id: 'traj-002',
+        timestamp: '2025-01-22T10:05:00Z',
+        agent: 'Lead',
+        type: 'command',
+        summary: 'Run build process',
+        outcome: 'success',
+        children: [
+          {
+            id: 'traj-003',
+            timestamp: '2025-01-22T10:05:01Z',
+            agent: 'Lead',
+            type: 'tool_call',
+            summary: 'Execute npm run build',
+            outcome: 'success',
+          },
+          {
+            id: 'traj-004',
+            timestamp: '2025-01-22T10:05:30Z',
+            agent: 'Lead',
+            type: 'message',
+            summary: 'Build completed',
+            outcome: 'success',
+          },
+        ],
+      };
+      const result = TrajectoryDecisionSchema.parse(decision);
+      expect(result.children).toHaveLength(2);
+      expect(result.children?.[0].type).toBe('tool_call');
+    });
+
+    it('should validate deeply nested children', () => {
+      const decision = {
+        id: 'root',
+        timestamp: '2025-01-22T10:00:00Z',
+        agent: 'Root',
+        type: 'command',
+        summary: 'Root command',
+        children: [
+          {
+            id: 'level-1',
+            timestamp: '2025-01-22T10:01:00Z',
+            agent: 'Root',
+            type: 'tool_call',
+            summary: 'Level 1',
+            children: [
+              {
+                id: 'level-2',
+                timestamp: '2025-01-22T10:02:00Z',
+                agent: 'Root',
+                type: 'file_edit',
+                summary: 'Level 2',
+              },
+            ],
+          },
+        ],
+      };
+      const result = TrajectoryDecisionSchema.parse(decision);
+      expect(result.children?.[0].children?.[0].id).toBe('level-2');
+    });
+  });
+
+  describe('TrajectorySchema', () => {
+    it('should validate complete trajectory', () => {
+      const trajectory = {
+        agentName: 'FullStack',
+        sessionId: 'session-001',
+        decisions: [
+          {
+            id: 'traj-001',
+            timestamp: '2025-01-22T10:00:00Z',
+            agent: 'FullStack',
+            type: 'tool_call',
+            summary: 'Start work',
+            outcome: 'success',
+          },
+        ],
+        startTime: '2025-01-22T10:00:00Z',
+        endTime: '2025-01-22T12:00:00Z',
+      };
+      const result = TrajectorySchema.parse(trajectory);
+      expect(result.agentName).toBe('FullStack');
+      expect(result.decisions).toHaveLength(1);
+      expect(result.endTime).toBe('2025-01-22T12:00:00Z');
+    });
+
+    it('should allow trajectory without endTime (in progress)', () => {
+      const trajectory = {
+        agentName: 'Worker',
+        sessionId: 'session-002',
+        decisions: [],
+        startTime: '2025-01-22T11:00:00Z',
+      };
+      const result = TrajectorySchema.parse(trajectory);
+      expect(result.endTime).toBeUndefined();
+      expect(result.decisions).toHaveLength(0);
+    });
+  });
+});

package/packages/api-types/src/schemas/decision.ts

@@ -0,0 +1,136 @@
+/**
+ * Decision Schemas
+ *
+ * Zod schemas for decision queue types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+
+/**
+ * Decision urgency/priority enum
+ */
+export const DecisionUrgencySchema = z.enum(['low', 'medium', 'high', 'critical']);
+export type DecisionUrgency = z.infer<typeof DecisionUrgencySchema>;
+
+/**
+ * Decision category enum
+ */
+export const DecisionCategorySchema = z.enum(['approval', 'choice', 'input', 'confirmation']);
+export type DecisionCategory = z.infer<typeof DecisionCategorySchema>;
+
+/**
+ * Decision option schema
+ */
+export const DecisionOptionSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+});
+export type DecisionOption = z.infer<typeof DecisionOptionSchema>;
+
+/**
+ * API Decision schema (from API response)
+ */
+export const ApiDecisionSchema = z.object({
+  id: z.string(),
+  agentName: z.string(),
+  title: z.string(),
+  description: z.string(),
+  options: z.array(DecisionOptionSchema).optional(),
+  urgency: DecisionUrgencySchema,
+  category: DecisionCategorySchema,
+  createdAt: z.string(),
+  expiresAt: z.string().optional(),
+  context: z.record(z.unknown()).optional(),
+});
+export type ApiDecision = z.infer<typeof ApiDecisionSchema>;
+
+/**
+ * Decision schema (component format)
+ */
+export const DecisionSchema = z.object({
+  id: z.string(),
+  agentName: z.string(),
+  timestamp: z.union([z.string(), z.number()]),
+  type: DecisionCategorySchema,
+  title: z.string(),
+  description: z.string(),
+  options: z.array(DecisionOptionSchema).optional(),
+  priority: DecisionUrgencySchema,
+  context: z.record(z.unknown()).optional(),
+  expiresAt: z.union([z.string(), z.number()]).optional(),
+});
+export type Decision = z.infer<typeof DecisionSchema>;
+
+/**
+ * Pending decision schema (simplified format)
+ */
+export const PendingDecisionSchema = z.object({
+  id: z.string(),
+  agent: z.string(),
+  question: z.string(),
+  options: z.array(z.string()).optional(),
+  context: z.string().optional(),
+  priority: DecisionUrgencySchema,
+  createdAt: z.string(),
+  expiresAt: z.string().optional(),
+});
+export type PendingDecision = z.infer<typeof PendingDecisionSchema>;
+
+/**
+ * Trajectory decision type enum (for tracking)
+ */
+export const TrajectoryDecisionTypeSchema = z.enum([
+  'tool_call',
+  'message',
+  'file_edit',
+  'command',
+  'question',
+]);
+export type TrajectoryDecisionType = z.infer<typeof TrajectoryDecisionTypeSchema>;
+
+/**
+ * Trajectory decision outcome enum
+ */
+export const TrajectoryDecisionOutcomeSchema = z.enum(['success', 'error', 'pending']);
+export type TrajectoryDecisionOutcome = z.infer<typeof TrajectoryDecisionOutcomeSchema>;
+
+/**
+ * Trajectory decision schema (for decision tracking)
+ */
+export const TrajectoryDecisionSchema: z.ZodType<TrajectoryDecision> = z.lazy(() =>
+  z.object({
+    id: z.string(),
+    timestamp: z.string(),
+    agent: z.string(),
+    type: TrajectoryDecisionTypeSchema,
+    summary: z.string(),
+    details: z.string().optional(),
+    context: z.string().optional(),
+    outcome: TrajectoryDecisionOutcomeSchema.optional(),
+    children: z.array(TrajectoryDecisionSchema).optional(),
+  })
+);
+export type TrajectoryDecision = {
+  id: string;
+  timestamp: string;
+  agent: string;
+  type: TrajectoryDecisionType;
+  summary: string;
+  details?: string;
+  context?: string;
+  outcome?: TrajectoryDecisionOutcome;
+  children?: TrajectoryDecision[];
+};
+
+/**
+ * Trajectory schema
+ */
+export const TrajectorySchema = z.object({
+  agentName: z.string(),
+  sessionId: z.string(),
+  decisions: z.array(TrajectoryDecisionSchema),
+  startTime: z.string(),
+  endTime: z.string().optional(),
+});
+export type Trajectory = z.infer<typeof TrajectorySchema>;

package/packages/api-types/src/schemas/fleet.test.ts

@@ -0,0 +1,212 @@
+/**
+ * Fleet Schema Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  PeerServerStatusSchema,
+  PeerServerSchema,
+  FleetDataSchema,
+  ProjectSchema,
+  FleetServerSchema,
+  FleetStatsSchema,
+} from './fleet.js';
+
+describe('Fleet Schemas', () => {
+  describe('PeerServerStatusSchema', () => {
+    it('should validate valid statuses', () => {
+      expect(PeerServerStatusSchema.parse('connected')).toBe('connected');
+      expect(PeerServerStatusSchema.parse('disconnected')).toBe('disconnected');
+      expect(PeerServerStatusSchema.parse('error')).toBe('error');
+    });
+
+    it('should reject invalid status', () => {
+      expect(() => PeerServerStatusSchema.parse('unknown')).toThrow();
+    });
+  });
+
+  describe('PeerServerSchema', () => {
+    it('should validate valid peer server', () => {
+      const server = {
+        id: 'server-1',
+        url: 'http://localhost:3888',
+        name: 'Primary Server',
+        status: 'connected',
+        agentCount: 5,
+        latency: 42,
+      };
+      const result = PeerServerSchema.parse(server);
+      expect(result.id).toBe('server-1');
+      expect(result.status).toBe('connected');
+      expect(result.agentCount).toBe(5);
+    });
+
+    it('should allow optional fields', () => {
+      const server = {
+        id: 'server-2',
+        url: 'http://localhost:3889',
+        status: 'disconnected',
+        agentCount: 0,
+      };
+      const result = PeerServerSchema.parse(server);
+      expect(result.name).toBeUndefined();
+      expect(result.latency).toBeUndefined();
+    });
+
+    it('should reject missing required fields', () => {
+      expect(() => PeerServerSchema.parse({ id: 'server-1' })).toThrow();
+    });
+  });
+
+  describe('FleetDataSchema', () => {
+    it('should validate fleet data with servers and agents', () => {
+      const fleet = {
+        servers: [
+          {
+            id: 'server-1',
+            url: 'http://localhost:3888',
+            status: 'connected',
+            agentCount: 2,
+          },
+        ],
+        agents: [
+          {
+            name: 'Agent1',
+            status: 'online',
+          },
+        ],
+        totalMessages: 150,
+      };
+      const result = FleetDataSchema.parse(fleet);
+      expect(result.servers).toHaveLength(1);
+      expect(result.agents).toHaveLength(1);
+      expect(result.totalMessages).toBe(150);
+    });
+
+    it('should allow empty arrays', () => {
+      const fleet = {
+        servers: [],
+        agents: [],
+        totalMessages: 0,
+      };
+      const result = FleetDataSchema.parse(fleet);
+      expect(result.servers).toHaveLength(0);
+      expect(result.agents).toHaveLength(0);
+    });
+  });
+
+  describe('ProjectSchema', () => {
+    it('should validate project with lead', () => {
+      const project = {
+        id: 'proj-1',
+        path: '/workspace/project',
+        name: 'My Project',
+        agents: [{ name: 'Worker', status: 'online' }],
+        lead: {
+          name: 'Lead',
+          connected: true,
+        },
+      };
+      const result = ProjectSchema.parse(project);
+      expect(result.lead?.name).toBe('Lead');
+      expect(result.lead?.connected).toBe(true);
+    });
+
+    it('should allow project without lead', () => {
+      const project = {
+        id: 'proj-2',
+        path: '/workspace/other',
+        agents: [],
+      };
+      const result = ProjectSchema.parse(project);
+      expect(result.lead).toBeUndefined();
+      expect(result.name).toBeUndefined();
+    });
+  });
+
+  describe('FleetServerSchema', () => {
+    it('should validate fleet server with all metrics', () => {
+      const server = {
+        id: 'fleet-server-1',
+        name: 'Production Server',
+        status: 'healthy',
+        agents: [
+          { name: 'Agent1', status: 'online' },
+          { name: 'Agent2', status: 'busy' },
+        ],
+        cpuUsage: 45.5,
+        memoryUsage: 72.3,
+        activeConnections: 12,
+        uptime: 86400,
+        lastHeartbeat: '2025-01-22T10:00:00Z',
+      };
+      const result = FleetServerSchema.parse(server);
+      expect(result.status).toBe('healthy');
+      expect(result.agents).toHaveLength(2);
+      expect(result.cpuUsage).toBe(45.5);
+    });
+
+    it('should validate degraded status', () => {
+      const server = {
+        id: 'fleet-server-2',
+        name: 'Secondary Server',
+        status: 'degraded',
+        agents: [],
+        cpuUsage: 95,
+        memoryUsage: 88,
+        activeConnections: 3,
+        uptime: 3600,
+        lastHeartbeat: '2025-01-22T09:59:00Z',
+      };
+      const result = FleetServerSchema.parse(server);
+      expect(result.status).toBe('degraded');
+    });
+
+    it('should reject invalid status', () => {
+      const server = {
+        id: 'fleet-server-3',
+        name: 'Bad Server',
+        status: 'unknown',
+        agents: [],
+        cpuUsage: 0,
+        memoryUsage: 0,
+        activeConnections: 0,
+        uptime: 0,
+        lastHeartbeat: '2025-01-22T10:00:00Z',
+      };
+      expect(() => FleetServerSchema.parse(server)).toThrow();
+    });
+  });
+
+  describe('FleetStatsSchema', () => {
+    it('should validate complete stats', () => {
+      const stats = {
+        totalAgents: 10,
+        onlineAgents: 7,
+        busyAgents: 3,
+        pendingDecisions: 2,
+        activeTasks: 5,
+      };
+      const result = FleetStatsSchema.parse(stats);
+      expect(result.totalAgents).toBe(10);
+      expect(result.onlineAgents).toBe(7);
+      expect(result.busyAgents).toBe(3);
+    });
+
+    it('should validate zero stats', () => {
+      const stats = {
+        totalAgents: 0,
+        onlineAgents: 0,
+        busyAgents: 0,
+        pendingDecisions: 0,
+        activeTasks: 0,
+      };
+      const result = FleetStatsSchema.parse(stats);
+      expect(result.totalAgents).toBe(0);
+    });
+
+    it('should reject missing fields', () => {
+      expect(() => FleetStatsSchema.parse({ totalAgents: 5 })).toThrow();
+    });
+  });
+});