onbuzz 3.3.0

package/src/interfaces/terminal/__tests__/smoke/advancedFeatures.test.js

@@ -0,0 +1,208 @@
+/**
+ * Phase 10 Advanced Features - Smoke Tests
+ * Verifies AgentSwitcher, AgentCreator, SettingsPanel, SearchPanel, and HelpPanel components
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Phase 10 - Advanced Features - Imports', () => {
+  test('AgentSwitcher component can be imported', async () => {
+    const { AgentSwitcher } = await import('../../components/AgentSwitcher.js');
+
+    expect(AgentSwitcher).toBeDefined();
+    expect(typeof AgentSwitcher).toBe('function');
+  }, 30000);
+
+  test('AgentCreator component can be imported', async () => {
+    const { AgentCreator } = await import('../../components/AgentCreator.js');
+
+    expect(AgentCreator).toBeDefined();
+    expect(typeof AgentCreator).toBe('function');
+  });
+
+  test('SettingsPanel component can be imported', async () => {
+    const { SettingsPanel } = await import('../../components/SettingsPanel.js');
+
+    expect(SettingsPanel).toBeDefined();
+    expect(typeof SettingsPanel).toBe('function');
+  });
+
+  test('SearchPanel component can be imported', async () => {
+    const { SearchPanel } = await import('../../components/SearchPanel.js');
+
+    expect(SearchPanel).toBeDefined();
+    expect(typeof SearchPanel).toBe('function');
+  });
+
+  test('HelpPanel component can be imported', async () => {
+    const { HelpPanel } = await import('../../components/HelpPanel.js');
+
+    expect(HelpPanel).toBeDefined();
+    expect(typeof HelpPanel).toBe('function');
+  });
+});
+
+describe('Phase 10 - AgentSwitcher - Structure', () => {
+  test('AgentSwitcher is a function component', async () => {
+    const { AgentSwitcher } = await import('../../components/AgentSwitcher.js');
+
+    expect(typeof AgentSwitcher).toBe('function');
+    expect(AgentSwitcher.prototype?.render).toBeUndefined();
+  });
+
+  test('AgentSwitcher is default export', async () => {
+    const module = await import('../../components/AgentSwitcher.js');
+
+    expect(module.default).toBeDefined();
+    expect(module.default).toBe(module.AgentSwitcher);
+  });
+});
+
+describe('Phase 10 - AgentCreator - Structure', () => {
+  test('AgentCreator is a function component', async () => {
+    const { AgentCreator } = await import('../../components/AgentCreator.js');
+
+    expect(typeof AgentCreator).toBe('function');
+    expect(AgentCreator.prototype?.render).toBeUndefined();
+  });
+
+  test('AgentCreator is default export', async () => {
+    const module = await import('../../components/AgentCreator.js');
+
+    expect(module.default).toBeDefined();
+    expect(module.default).toBe(module.AgentCreator);
+  });
+});
+
+describe('Phase 10 - SettingsPanel - Structure', () => {
+  test('SettingsPanel is a function component', async () => {
+    const { SettingsPanel } = await import('../../components/SettingsPanel.js');
+
+    expect(typeof SettingsPanel).toBe('function');
+    expect(SettingsPanel.prototype?.render).toBeUndefined();
+  });
+
+  test('SettingsPanel is default export', async () => {
+    const module = await import('../../components/SettingsPanel.js');
+
+    expect(module.default).toBeDefined();
+    expect(module.default).toBe(module.SettingsPanel);
+  });
+});
+
+describe('Phase 10 - SearchPanel - Structure', () => {
+  test('SearchPanel is a function component', async () => {
+    const { SearchPanel } = await import('../../components/SearchPanel.js');
+
+    expect(typeof SearchPanel).toBe('function');
+    expect(SearchPanel.prototype?.render).toBeUndefined();
+  });
+
+  test('SearchPanel is default export', async () => {
+    const module = await import('../../components/SearchPanel.js');
+
+    expect(module.default).toBeDefined();
+    expect(module.default).toBe(module.SearchPanel);
+  });
+});
+
+describe('Phase 10 - HelpPanel - Structure', () => {
+  test('HelpPanel is a function component', async () => {
+    const { HelpPanel } = await import('../../components/HelpPanel.js');
+
+    expect(typeof HelpPanel).toBe('function');
+    expect(HelpPanel.prototype?.render).toBeUndefined();
+  });
+
+  test('HelpPanel is default export', async () => {
+    const module = await import('../../components/HelpPanel.js');
+
+    expect(module.default).toBeDefined();
+    expect(module.default).toBe(module.HelpPanel);
+  });
+});
+
+describe('Phase 10 - Integration with Layout', () => {
+  test('Layout component can import all Phase 10 components', async () => {
+    const [
+      agentSwitcherModule,
+      agentCreatorModule,
+      settingsPanelModule,
+      searchPanelModule,
+      helpPanelModule,
+    ] = await Promise.all([
+      import('../../components/AgentSwitcher.js'),
+      import('../../components/AgentCreator.js'),
+      import('../../components/SettingsPanel.js'),
+      import('../../components/SearchPanel.js'),
+      import('../../components/HelpPanel.js'),
+    ]);
+
+    expect(agentSwitcherModule.AgentSwitcher).toBeDefined();
+    expect(agentCreatorModule.AgentCreator).toBeDefined();
+    expect(settingsPanelModule.SettingsPanel).toBeDefined();
+    expect(searchPanelModule.SearchPanel).toBeDefined();
+    expect(helpPanelModule.HelpPanel).toBeDefined();
+  });
+
+  test('Layout component still loads after Phase 10 additions', async () => {
+    const { Layout } = await import('../../components/Layout.js');
+
+    expect(Layout).toBeDefined();
+    expect(typeof Layout).toBe('function');
+  });
+
+  test('All Phase 10 components use React and Ink', async () => {
+    const React = await import('react');
+    const ink = await import('ink');
+
+    // Verify dependencies are available
+    expect(React.createElement).toBeDefined();
+    expect(React.useState).toBeDefined();
+    expect(ink.Box).toBeDefined();
+    expect(ink.Text).toBeDefined();
+    expect(ink.useInput).toBeDefined();
+  });
+});
+
+describe('Phase 10 - Component Constants and Configurations', () => {
+  test('AgentCreator defines step constants', async () => {
+    // We can't directly access module constants, but we can verify the module structure
+    const module = await import('../../components/AgentCreator.js');
+
+    expect(module.AgentCreator).toBeDefined();
+    // The component uses STEPS, MODELS, MODES internally
+  });
+
+  test('SettingsPanel defines category constants', async () => {
+    const module = await import('../../components/SettingsPanel.js');
+
+    expect(module.SettingsPanel).toBeDefined();
+    // The component uses CATEGORIES, CATEGORY_TITLES internally
+  });
+
+  test('HelpPanel defines shortcut configurations', async () => {
+    const module = await import('../../components/HelpPanel.js');
+
+    expect(module.HelpPanel).toBeDefined();
+    // The component uses SHORTCUTS and TIPS internally
+  });
+});
+
+describe('Phase 10 - All Components Export Correctly', () => {
+  test('All components can be imported together without conflicts', async () => {
+    const components = await Promise.all([
+      import('../../components/AgentSwitcher.js'),
+      import('../../components/AgentCreator.js'),
+      import('../../components/SettingsPanel.js'),
+      import('../../components/SearchPanel.js'),
+      import('../../components/HelpPanel.js'),
+    ]);
+
+    // Verify no naming conflicts
+    const names = components.map((mod) => Object.keys(mod)[0]);
+    const uniqueNames = new Set(names);
+
+    expect(uniqueNames.size).toBe(names.length); // All unique names
+  });
+});

package/src/interfaces/terminal/__tests__/smoke/agentControl.test.js

@@ -0,0 +1,236 @@
+/**
+ * Agent Control Management - Smoke Tests
+ * Verifies that agent control modules can be imported and basic functionality works
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Agent Control Management - Imports', () => {
+  test('useAgentControl hook can be imported', async () => {
+    const { useAgentControl } = await import('../../state/useAgentControl.js');
+
+    expect(useAgentControl).toBeDefined();
+    expect(typeof useAgentControl).toBe('function');
+  });
+
+  test('useAgentControl is default export', async () => {
+    const module = await import('../../state/useAgentControl.js');
+
+    expect(module.default).toBeDefined();
+    expect(typeof module.default).toBe('function');
+    expect(module.default).toBe(module.useAgentControl);
+  });
+});
+
+describe('Agent Control Management - Constants', () => {
+  test('AGENT_MODE constants are defined', async () => {
+    const { AGENT_MODE } = await import('../../config/constants.js');
+
+    expect(AGENT_MODE).toBeDefined();
+    expect(AGENT_MODE.CHAT).toBe('CHAT');
+    expect(AGENT_MODE.AGENT).toBe('AGENT');
+  });
+
+  test('MODEL_CATEGORY constants are defined', async () => {
+    const { MODEL_CATEGORY } = await import('../../config/constants.js');
+
+    expect(MODEL_CATEGORY).toBeDefined();
+    expect(MODEL_CATEGORY.ANTHROPIC).toBe('anthropic');
+    expect(MODEL_CATEGORY.OPENAI).toBe('openai');
+    expect(MODEL_CATEGORY.DEEPSEEK).toBe('deepseek');
+    expect(MODEL_CATEGORY.MICROSOFT).toBe('microsoft');
+  });
+
+  test('Mode and model API endpoints are defined', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toBe('/api/agents/:agentId/mode');
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toBe('/api/agents/:agentId/mode');
+    expect(API_ENDPOINTS.LLM_MODELS).toBe('/api/llm/models');
+  });
+
+  test('WS_MESSAGE_TYPE includes mode and model change events', async () => {
+    const { WS_MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    expect(WS_MESSAGE_TYPE).toBeDefined();
+    expect(WS_MESSAGE_TYPE.AGENT_MODE_CHANGED).toBe('agent_mode_changed');
+  });
+});
+
+describe('Agent Control Management - Integration', () => {
+  test('useAgentControl hook integrates with Session and MessageRouter', async () => {
+    const { useAgentControl } = await import('../../state/useAgentControl.js');
+    const { SessionManager } = await import('../../api/session.js');
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    // Create dependencies
+    const sessionManager = new SessionManager('localhost', 8080);
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const messageRouter = new MessageRouter(wsManager);
+
+    // Verify all components exist
+    expect(sessionManager).toBeDefined();
+    expect(messageRouter).toBeDefined();
+
+    // useAgentControl expects these as parameters (including currentAgent)
+    // (we can't actually call the hook outside React, but we verify the interface)
+    expect(typeof useAgentControl).toBe('function');
+  });
+
+  test('Full agent control stack can be imported together', async () => {
+    const [
+      constantsModule,
+      sessionModule,
+      websocketModule,
+      routerModule,
+      agentControlModule,
+    ] = await Promise.all([
+      import('../../config/constants.js'),
+      import('../../api/session.js'),
+      import('../../api/websocket.js'),
+      import('../../api/messageRouter.js'),
+      import('../../state/useAgentControl.js'),
+    ]);
+
+    // Verify all modules loaded
+    expect(constantsModule.AGENT_MODE).toBeDefined();
+    expect(constantsModule.MODEL_CATEGORY).toBeDefined();
+    expect(constantsModule.API_ENDPOINTS).toBeDefined();
+    expect(sessionModule.SessionManager).toBeDefined();
+    expect(websocketModule.WebSocketManager).toBeDefined();
+    expect(routerModule.MessageRouter).toBeDefined();
+    expect(agentControlModule.useAgentControl).toBeDefined();
+  });
+});
+
+describe('Agent Control Management - API Endpoints Validation', () => {
+  test('Agent mode endpoints follow RESTful pattern', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    // Verify endpoint paths
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toMatch(/^\/api\/agents/);
+
+    // Verify parameter placeholders
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toContain(':agentId');
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toContain(':agentId');
+  });
+
+  test('LLM models endpoint exists', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.LLM_MODELS).toBeDefined();
+    expect(API_ENDPOINTS.LLM_MODELS).toBe('/api/llm/models');
+  });
+
+  test('Orchestrator endpoint exists for model and config operations', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBeDefined();
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+  });
+});
+
+describe('Agent Control Management - Hook Interface Verification', () => {
+  test('useAgentControl returns expected interface shape', async () => {
+    const { useAgentControl } = await import('../../state/useAgentControl.js');
+
+    // We can verify the function signature
+    expect(useAgentControl.length).toBe(3); // sessionManager, messageRouter, currentAgent
+  });
+});
+
+describe('Agent Control Management - Constants Validation', () => {
+  test('AGENT_MODE has exactly two modes', async () => {
+    const { AGENT_MODE } = await import('../../config/constants.js');
+
+    const modeKeys = Object.keys(AGENT_MODE);
+    expect(modeKeys.length).toBe(2);
+    expect(modeKeys).toContain('CHAT');
+    expect(modeKeys).toContain('AGENT');
+  });
+
+  test('AGENT_MODE values are uppercase', async () => {
+    const { AGENT_MODE } = await import('../../config/constants.js');
+
+    expect(AGENT_MODE.CHAT).toBe('CHAT');
+    expect(AGENT_MODE.AGENT).toBe('AGENT');
+    expect(AGENT_MODE.CHAT).toBe(AGENT_MODE.CHAT.toUpperCase());
+    expect(AGENT_MODE.AGENT).toBe(AGENT_MODE.AGENT.toUpperCase());
+  });
+
+  test('MODEL_CATEGORY values are lowercase', async () => {
+    const { MODEL_CATEGORY } = await import('../../config/constants.js');
+
+    expect(MODEL_CATEGORY.ANTHROPIC).toBe('anthropic');
+    expect(MODEL_CATEGORY.OPENAI).toBe('openai');
+    expect(MODEL_CATEGORY.DEEPSEEK).toBe('deepseek');
+    expect(MODEL_CATEGORY.MICROSOFT).toBe('microsoft');
+
+    expect(MODEL_CATEGORY.ANTHROPIC).toBe(MODEL_CATEGORY.ANTHROPIC.toLowerCase());
+    expect(MODEL_CATEGORY.OPENAI).toBe(MODEL_CATEGORY.OPENAI.toLowerCase());
+  });
+
+  test('MODEL_CATEGORY includes major LLM providers', async () => {
+    const { MODEL_CATEGORY } = await import('../../config/constants.js');
+
+    const categories = Object.keys(MODEL_CATEGORY);
+    expect(categories).toContain('ANTHROPIC');
+    expect(categories).toContain('OPENAI');
+    expect(categories).toContain('DEEPSEEK');
+    expect(categories).toContain('MICROSOFT');
+  });
+});
+
+describe('Agent Control Management - WebSocket Event Handlers', () => {
+  test('MessageRouter has mode change event handler registered', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+    const { WS_MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    // Verify mode change event handler is registered
+    expect(router.hasHandler(WS_MESSAGE_TYPE.AGENT_MODE_CHANGED)).toBe(true);
+  });
+});
+
+describe('Agent Control Management - Mode Switching Logic', () => {
+  test('AGENT_MODE supports toggling between modes', async () => {
+    const { AGENT_MODE } = await import('../../config/constants.js');
+
+    // Toggle from CHAT to AGENT
+    let currentMode = AGENT_MODE.CHAT;
+    let newMode = currentMode === AGENT_MODE.CHAT ? AGENT_MODE.AGENT : AGENT_MODE.CHAT;
+    expect(newMode).toBe(AGENT_MODE.AGENT);
+
+    // Toggle from AGENT to CHAT
+    currentMode = AGENT_MODE.AGENT;
+    newMode = currentMode === AGENT_MODE.CHAT ? AGENT_MODE.AGENT : AGENT_MODE.CHAT;
+    expect(newMode).toBe(AGENT_MODE.CHAT);
+  });
+});
+
+describe('Agent Control Management - Model Filtering', () => {
+  test('MODEL_CATEGORY can be used to filter models by category', async () => {
+    const { MODEL_CATEGORY } = await import('../../config/constants.js');
+
+    // Mock model list
+    const mockModels = [
+      { id: 'claude-3-5-sonnet', category: MODEL_CATEGORY.ANTHROPIC },
+      { id: 'gpt-4', category: MODEL_CATEGORY.OPENAI },
+      { id: 'deepseek-chat', category: MODEL_CATEGORY.DEEPSEEK },
+    ];
+
+    // Filter by category
+    const anthropicModels = mockModels.filter(m => m.category === MODEL_CATEGORY.ANTHROPIC);
+    const openAIModels = mockModels.filter(m => m.category === MODEL_CATEGORY.OPENAI);
+
+    expect(anthropicModels.length).toBe(1);
+    expect(anthropicModels[0].id).toBe('claude-3-5-sonnet');
+    expect(openAIModels.length).toBe(1);
+    expect(openAIModels[0].id).toBe('gpt-4');
+  });
+});

package/src/interfaces/terminal/__tests__/smoke/agents.test.js

@@ -0,0 +1,138 @@
+/**
+ * Agent Management - Smoke Tests
+ * Verifies that agent management modules can be imported and basic functionality works
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Agent Management - Imports', () => {
+  test('useAgents hook can be imported', async () => {
+    const { useAgents } = await import('../../state/useAgents.js');
+
+    expect(useAgents).toBeDefined();
+    expect(typeof useAgents).toBe('function');
+  });
+
+  test('useAgents is default export', async () => {
+    const module = await import('../../state/useAgents.js');
+
+    expect(module.default).toBeDefined();
+    expect(typeof module.default).toBe('function');
+    expect(module.default).toBe(module.useAgents);
+  });
+});
+
+describe('Agent Management - Constants', () => {
+  test('AGENT_MODE constants are defined', async () => {
+    const { AGENT_MODE } = await import('../../config/constants.js');
+
+    expect(AGENT_MODE).toBeDefined();
+    expect(AGENT_MODE.CHAT).toBe('CHAT');
+    expect(AGENT_MODE.AGENT).toBe('AGENT');
+  });
+
+  test('AGENT_STATUS constants are defined', async () => {
+    const { AGENT_STATUS } = await import('../../config/constants.js');
+
+    expect(AGENT_STATUS).toBeDefined();
+    expect(AGENT_STATUS.ACTIVE).toBe('active');
+    expect(AGENT_STATUS.PAUSED).toBe('paused');
+    expect(AGENT_STATUS.IDLE).toBe('idle');
+    expect(AGENT_STATUS.ERROR).toBe('error');
+    expect(AGENT_STATUS.ARCHIVED).toBe('archived');
+  });
+
+  test('Agent API endpoints are defined', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.AGENTS_AVAILABLE).toBe('/api/agents/available');
+    expect(API_ENDPOINTS.AGENTS_METADATA).toBe('/api/agents/:agentId/metadata');
+    expect(API_ENDPOINTS.AGENTS_IMPORT).toBe('/api/agents/import');
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toBe('/api/agents/:agentId/mode');
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toBe('/api/agents/:agentId/mode');
+    expect(API_ENDPOINTS.AGENTS_STOP).toBe('/api/agents/:agentId/stop');
+  });
+
+  test('AGENT_TEMPLATES constants are defined', async () => {
+    const { AGENT_TEMPLATES } = await import('../../config/constants.js');
+
+    expect(AGENT_TEMPLATES).toBeDefined();
+    expect(AGENT_TEMPLATES.CODING_ASSISTANT).toBe('coding-assistant');
+    expect(AGENT_TEMPLATES.DATA_ANALYST).toBe('data-analyst');
+    expect(AGENT_TEMPLATES.CREATIVE_WRITER).toBe('creative-writer');
+    expect(AGENT_TEMPLATES.SYSTEM_ADMINISTRATOR).toBe('system-administrator');
+    expect(AGENT_TEMPLATES.CUSTOM).toBe('custom');
+  });
+});
+
+describe('Agent Management - Integration', () => {
+  test('useAgents hook integrates with Session and MessageRouter', async () => {
+    const { useAgents } = await import('../../state/useAgents.js');
+    const { SessionManager } = await import('../../api/session.js');
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    // Create dependencies
+    const sessionManager = new SessionManager('localhost', 8080);
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const messageRouter = new MessageRouter(wsManager);
+
+    // Verify all components exist
+    expect(sessionManager).toBeDefined();
+    expect(messageRouter).toBeDefined();
+
+    // useAgents expects these as parameters
+    // (we can't actually call the hook outside React, but we verify the interface)
+    expect(typeof useAgents).toBe('function');
+  });
+
+  test('Full agent management stack can be imported together', async () => {
+    const [
+      constantsModule,
+      sessionModule,
+      websocketModule,
+      routerModule,
+      agentsModule,
+    ] = await Promise.all([
+      import('../../config/constants.js'),
+      import('../../api/session.js'),
+      import('../../api/websocket.js'),
+      import('../../api/messageRouter.js'),
+      import('../../state/useAgents.js'),
+    ]);
+
+    // Verify all modules loaded
+    expect(constantsModule.AGENT_MODE).toBeDefined();
+    expect(sessionModule.SessionManager).toBeDefined();
+    expect(websocketModule.WebSocketManager).toBeDefined();
+    expect(routerModule.MessageRouter).toBeDefined();
+    expect(agentsModule.useAgents).toBeDefined();
+  });
+});
+
+describe('Agent Management - API Endpoints Validation', () => {
+  test('All agent endpoints follow RESTful pattern', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    // Verify endpoint paths
+    expect(API_ENDPOINTS.AGENTS_AVAILABLE).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_METADATA).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_IMPORT).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toMatch(/^\/api\/agents/);
+    expect(API_ENDPOINTS.AGENTS_STOP).toMatch(/^\/api\/agents/);
+
+    // Verify parameter placeholders
+    expect(API_ENDPOINTS.AGENTS_METADATA).toContain(':agentId');
+    expect(API_ENDPOINTS.AGENTS_MODE_SET).toContain(':agentId');
+    expect(API_ENDPOINTS.AGENTS_MODE_GET).toContain(':agentId');
+    expect(API_ENDPOINTS.AGENTS_STOP).toContain(':agentId');
+  });
+
+  test('Orchestrator endpoint exists for agent operations', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBeDefined();
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+  });
+});