agent-relay 2.3.4 → 2.3.5

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

@@ -1,324 +0,0 @@
-/**
- * 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

@@ -1,136 +0,0 @@
-/**
- * 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

@@ -1,212 +0,0 @@
-/**
- * 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();
-    });
-  });
-});