agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/providers.spec.ts

@@ -8,25 +8,27 @@ describe('provider selection', () => {
       cli: {
         agent_provider: 'custom',
         agent_model: 'cli-model',
-        provider_config_env: 'CLI_CONFIG'
+        provider_config_env: 'CLI_CONFIG',
       },
       env: {
         AOP_AGENT_PROVIDER: 'codex',
         AOP_AGENT_MODEL: 'env-model',
-        AOP_PROVIDER_CONFIG_ENV: 'ENV_CONFIG'
+        CLI_CONFIG: 'cli-token',
+        AOP_PROVIDER_CONFIG_ENV: 'ENV_CONFIG',
       },
       agentsConfig: {
         runtime: {
           default_provider: 'claude',
           default_model: 'cfg-model',
-          provider_config_env: 'CFG_CONFIG'
-        }
-      }
+          provider_config_env: 'CFG_CONFIG',
+        },
+      },
     });
 
     expect(selection.provider).toBe('custom');
     expect(selection.model).toBe('cli-model');
     expect(selection.provider_config_env).toBe('CLI_CONFIG');
+    expect(selection.provider_config_ref).toBe('cli-token');
   });
 
   it('GIVEN_no_provider_WHEN_resolving_THEN_throws_agent_provider_not_configured', () => {
@@ -34,8 +36,8 @@ describe('provider selection', () => {
       resolveProviderSelection({
         cli: {},
         env: {},
-        agentsConfig: {}
-      })
+        agentsConfig: {},
+      }),
     ).toThrow(ERROR_CODES.AGENT_PROVIDER_NOT_CONFIGURED);
   });
 
@@ -44,31 +46,51 @@ describe('provider selection', () => {
       resolveProviderSelection({
         cli: { agent_provider: 'bogus' },
         env: {},
-        agentsConfig: {}
-      })
+        agentsConfig: {},
+      }),
     ).toThrow(ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
   });
 
-  it('GIVEN_non_custom_provider_without_credentials_WHEN_resolving_THEN_throws_provider_auth_missing', () => {
+  it('GIVEN_credential_required_provider_without_credentials_WHEN_resolving_THEN_throws_provider_auth_missing', () => {
     expect(() =>
       resolveProviderSelection({
-        cli: { agent_provider: 'codex', provider_config_env: 'AOP_KEY' },
+        cli: { agent_provider: 'gemini', provider_config_env: 'GEMINI_API_KEY' },
         env: {},
-        agentsConfig: {}
-      })
+        agentsConfig: {},
+      }),
     ).toThrow(ERROR_CODES.PROVIDER_AUTH_MISSING);
   });
 
+  it('GIVEN_codex_provider_without_credentials_WHEN_resolving_THEN_does_not_throw', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'codex' },
+      env: {},
+      agentsConfig: {},
+    });
+    expect(selection.provider).toBe('codex');
+    expect(selection.provider_config_ref).toBeNull();
+  });
+
+  it('GIVEN_claude_provider_without_credentials_WHEN_resolving_THEN_does_not_throw', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'claude' },
+      env: {},
+      agentsConfig: {},
+    });
+    expect(selection.provider).toBe('claude');
+    expect(selection.provider_config_ref).toBeNull();
+  });
+
   it('GIVEN_non_custom_provider_without_model_WHEN_resolving_THEN_uses_default_model_name', () => {
     const selection = resolveProviderSelection({
       cli: {
         agent_provider: 'codex',
-        provider_config_env: 'AOP_KEY'
+        provider_config_env: 'AOP_KEY',
       },
       env: {
-        AOP_KEY: 'token'
+        AOP_KEY: 'token',
       },
-      agentsConfig: {}
+      agentsConfig: {},
     });
 
     expect(selection.model).toBe('codex-default');
@@ -78,23 +100,74 @@ describe('provider selection', () => {
   it('GIVEN_custom_provider_without_credentials_WHEN_resolving_THEN_allows_null_config_ref', () => {
     const selection = resolveProviderSelection({
       cli: {
-        agent_provider: 'custom'
+        agent_provider: 'custom',
       },
       env: {},
-      agentsConfig: {}
+      agentsConfig: {},
     });
 
     expect(selection.provider).toBe('custom');
     expect(selection.provider_config_ref).toBeNull();
   });
 
+  it('GIVEN_AOP_provider_config_env_holds_direct_credential_WHEN_resolving_THEN_uses_direct_value', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'gemini',
+      },
+      env: {
+        AOP_PROVIDER_CONFIG_ENV: 'direct-bootstrap-key',
+      },
+      agentsConfig: {},
+    });
+
+    expect(selection.provider_config_env).toBe('AOP_PROVIDER_CONFIG_ENV');
+    expect(selection.provider_config_ref).toBe('direct-bootstrap-key');
+  });
+
+  it('GIVEN_AOP_provider_config_env_points_to_existing_env_var_WHEN_resolving_THEN_uses_legacy_indirection', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'gemini',
+      },
+      env: {
+        AOP_PROVIDER_CONFIG_ENV: 'GEMINI_API_KEY',
+        GEMINI_API_KEY: 'legacy-indirect-key',
+      },
+      agentsConfig: {},
+    });
+
+    expect(selection.provider_config_env).toBe('GEMINI_API_KEY');
+    expect(selection.provider_config_ref).toBe('legacy-indirect-key');
+  });
+
+  it('GIVEN_cli_provider_config_env_missing_but_runtime_provider_config_env_present_WHEN_resolving_THEN_runtime_env_name_is_used', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'gemini',
+        provider_config_env: 'MISSING_CLI_KEY',
+      },
+      env: {
+        CFG_KEY: 'cfg-token',
+      },
+      agentsConfig: {
+        runtime: {
+          provider_config_env: 'CFG_KEY',
+        },
+      },
+    });
+
+    expect(selection.provider_config_env).toBe('CFG_KEY');
+    expect(selection.provider_config_ref).toBe('cfg-token');
+  });
+
   it('GIVEN_kiro_cli_provider_without_credentials_WHEN_resolving_THEN_allows_null_config_ref', () => {
     const selection = resolveProviderSelection({
       cli: {
-        agent_provider: 'kiro-cli'
+        agent_provider: 'kiro-cli',
       },
       env: {},
-      agentsConfig: {}
+      agentsConfig: {},
     });
 
     expect(selection.provider).toBe('kiro-cli');
@@ -104,7 +177,7 @@ describe('provider selection', () => {
   it('GIVEN_provider_configured_agent_config_WHEN_resolving_THEN_returns_provider_specific_config', () => {
     const selection = resolveProviderSelection({
       cli: {
-        agent_provider: 'kiro-cli'
+        agent_provider: 'kiro-cli',
       },
       env: {},
       agentsConfig: {
@@ -112,16 +185,16 @@ describe('provider selection', () => {
           provider_configs: {
             'kiro-cli': {
               command: 'kiro-cli',
-              args: ['chat', '--agent', 'dev']
-            }
-          }
-        }
-      }
+              args: ['chat', '--agent', 'dev'],
+            },
+          },
+        },
+      },
     });
 
     expect(selection.agent_config).toEqual({
       command: 'kiro-cli',
-      args: ['chat', '--agent', 'dev']
+      args: ['chat', '--agent', 'dev'],
     });
   });
 
@@ -131,8 +204,8 @@ describe('provider selection', () => {
         agent_provider: 'copilot',
         agent_config: JSON.stringify({
           command: 'copilot',
-          args: ['chat', '--agent', 'review']
-        })
+          args: ['chat', '--agent', 'review'],
+        }),
       },
       env: {},
       agentsConfig: {
@@ -140,16 +213,16 @@ describe('provider selection', () => {
           provider_configs: {
             copilot: {
               command: 'copilot',
-              args: ['chat']
-            }
-          }
-        }
-      }
+              args: ['chat'],
+            },
+          },
+        },
+      },
     });
 
     expect(selection.agent_config).toEqual({
       command: 'copilot',
-      args: ['chat', '--agent', 'review']
+      args: ['chat', '--agent', 'review'],
     });
   });
 
@@ -158,11 +231,11 @@ describe('provider selection', () => {
       resolveProviderSelection({
         cli: {
           agent_provider: 'kiro-cli',
-          agent_config: '{not-json'
+          agent_config: '{not-json',
         },
         env: {},
-        agentsConfig: {}
-      })
+        agentsConfig: {},
+      }),
     ).toThrow(ERROR_CODES.INVALID_CLI_ARGS);
   });
 
@@ -171,7 +244,7 @@ describe('provider selection', () => {
     const selection = resolveProviderSelection({
       cli: { agent_provider: 'kiro-cli' },
       env: { AOP_AGENT_CONFIG: JSON.stringify(agentConfig) },
-      agentsConfig: {}
+      agentsConfig: {},
     });
     expect(selection.agent_config).toEqual(agentConfig);
   });
@@ -181,7 +254,7 @@ describe('provider selection', () => {
     const selection = resolveProviderSelection({
       cli: { agent_provider: 'kiro-cli' },
       env: { AOP_AGENT_CONFIG_JSON: JSON.stringify(agentConfig) },
-      agentsConfig: {}
+      agentsConfig: {},
     });
     expect(selection.agent_config).toEqual(agentConfig);
   });
@@ -191,8 +264,8 @@ describe('provider selection', () => {
       resolveProviderSelection({
         cli: { agent_provider: 'kiro-cli' },
         env: { AOP_AGENT_CONFIG: JSON.stringify([1, 2, 3]) },
-        agentsConfig: {}
-      })
+        agentsConfig: {},
+      }),
     ).toThrow(ERROR_CODES.INVALID_CLI_ARGS);
   });
 
@@ -201,7 +274,7 @@ describe('provider selection', () => {
     const selection = resolveProviderSelection({
       cli: { agent_provider: 'kiro-cli' },
       env: {},
-      agentsConfig: { runtime: { default_agent_config: defaultConfig } }
+      agentsConfig: { runtime: { default_agent_config: defaultConfig } },
     });
     expect(selection.agent_config).toEqual(defaultConfig);
   });
@@ -212,7 +285,7 @@ describe('NullWorkerProvider', () => {
     provider: 'custom' as const,
     model: 'test-model',
     provider_config_env: null,
-    provider_config_ref: null
+    provider_config_ref: null,
   };
 
   it('GIVEN_system_prompt_WHEN_createSession_THEN_marks_prompt_loaded', async () => {
@@ -230,13 +303,13 @@ describe('NullWorkerProvider', () => {
     const output = await provider.runWorker({
       role: 'planner',
       feature_id: 'feature_two',
-      context_bundle: { state: { front_matter: { status: 'building' } } }
+      context_bundle: { state: { front_matter: { status: 'building' } } },
     });
 
     expect(output).toMatchObject({
       type: 'NOTE',
       content: 'Planner session active for feature_two.',
-      context_snapshot: { status: 'building' }
+      context_snapshot: { status: 'building' },
     });
   });
 
@@ -246,7 +319,7 @@ describe('NullWorkerProvider', () => {
 
     expect(output).toMatchObject({
       type: 'NOTE',
-      content: 'qa session active for feature_three.'
+      content: 'qa session active for feature_three.',
     });
   });
 
@@ -254,13 +327,13 @@ describe('NullWorkerProvider', () => {
     const provider = new NullWorkerProvider(selection);
     const output = await provider.runWorker({
       role: 'planner',
-      feature_id: 'feature_unknown'
+      feature_id: 'feature_unknown',
     });
 
     expect(output).toMatchObject({
       type: 'NOTE',
       content: 'Planner session active for feature_unknown.',
-      context_snapshot: { status: 'unknown' }
+      context_snapshot: { status: 'unknown' },
     });
   });
 
@@ -269,13 +342,13 @@ describe('NullWorkerProvider', () => {
     const output = await provider.runWorker({
       role: 'planner',
       feature_id: 'feature_weird',
-      context_bundle: { state: 'invalid' as unknown as Record<string, unknown> }
+      context_bundle: { state: 'invalid' as unknown as Record<string, unknown> },
     });
 
     expect(output).toMatchObject({
       type: 'NOTE',
       content: 'Planner session active for feature_weird.',
-      context_snapshot: { status: 'unknown' }
+      context_snapshot: { status: 'unknown' },
     });
   });
 
@@ -286,16 +359,16 @@ describe('NullWorkerProvider', () => {
 
   it('GIVEN_codex_provider_WHEN_attachToSession_called_THEN_executes_interactive_attach_command', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+      run: vi.fn(async () => ({ exitCode: 0, signal: null })),
     };
     const provider = new NullWorkerProvider(
       {
         provider: 'codex',
         model: 'codex-default',
         provider_config_env: null,
-        provider_config_ref: null
+        provider_config_ref: null,
       },
-      { commandRunner: runner }
+      { commandRunner: runner },
     );
 
     expect(provider.attachToSession).toBeTypeOf('function');
@@ -304,22 +377,22 @@ describe('NullWorkerProvider', () => {
     expect(runner.run).toHaveBeenCalledWith(
       'codex',
       ['chat', '--session', 'session-codex-1'],
-      expect.objectContaining({ interactive: true })
+      expect.objectContaining({ interactive: true }),
     );
   });
 
   it('GIVEN_claude_provider_WHEN_sendMessage_called_THEN_executes_send_command_with_message_argument', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+      run: vi.fn(async () => ({ exitCode: 0, signal: null })),
     };
     const provider = new NullWorkerProvider(
       {
         provider: 'claude',
         model: 'claude-default',
         provider_config_env: null,
-        provider_config_ref: null
+        provider_config_ref: null,
       },
-      { commandRunner: runner }
+      { commandRunner: runner },
     );
 
     expect(provider.sendMessage).toBeTypeOf('function');
@@ -328,7 +401,7 @@ describe('NullWorkerProvider', () => {
     expect(runner.run).toHaveBeenCalledWith(
       'claude-code',
       ['chat', '--session', 'session-claude-1', '--message', 'Please rerun the QA gate'],
-      expect.objectContaining({ interactive: false })
+      expect.objectContaining({ interactive: false }),
     );
   });
 
@@ -337,7 +410,7 @@ describe('NullWorkerProvider', () => {
       provider: 'custom',
       model: 'custom-default',
       provider_config_env: null,
-      provider_config_ref: null
+      provider_config_ref: null,
     });
 
     expect(provider.attachToSession).toBeUndefined();
@@ -346,7 +419,7 @@ describe('NullWorkerProvider', () => {
 
   it('GIVEN_custom_provider_with_agent_config_overrides_WHEN_attach_called_THEN_uses_overridden_command_template', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+      run: vi.fn(async () => ({ exitCode: 0, signal: null })),
     };
     const provider = new NullWorkerProvider(
       {
@@ -356,17 +429,17 @@ describe('NullWorkerProvider', () => {
         provider_config_ref: null,
         agent_config: {
           attach_command: 'my-agent-cli',
-          attach_args: ['open', '--session-id', '{session_id}']
-        }
+          attach_args: ['open', '--session-id', '{session_id}'],
+        },
       },
-      { commandRunner: runner }
+      { commandRunner: runner },
     );
 
     await provider.attachToSession?.('session-custom-1');
     expect(runner.run).toHaveBeenCalledWith(
       'my-agent-cli',
       ['open', '--session-id', 'session-custom-1'],
-      expect.objectContaining({ interactive: true })
+      expect.objectContaining({ interactive: true }),
     );
   });
 });
@@ -374,47 +447,65 @@ describe('NullWorkerProvider', () => {
 describe('NullWorkerProvider executeCommand error branches', () => {
   it('GIVEN_command_exits_with_127_WHEN_executeCommand_called_THEN_throws_unsupported_agent_provider', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 127, signal: null, errorCode: undefined }))
+      run: vi.fn(async () => ({ exitCode: 127, signal: null, errorCode: undefined })),
     };
     const provider = new NullWorkerProvider(
-      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
-      { commandRunner: runner }
+      {
+        provider: 'claude',
+        model: 'claude-default',
+        provider_config_env: null,
+        provider_config_ref: null,
+      },
+      { commandRunner: runner },
     );
     await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
-      code: 'unsupported_agent_provider'
+      code: 'unsupported_agent_provider',
     });
   });
 
   it('GIVEN_command_exits_with_ENOENT_error_code_WHEN_executeCommand_called_THEN_throws_unsupported_agent_provider', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: 'ENOENT' }))
+      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: 'ENOENT' })),
     };
     const provider = new NullWorkerProvider(
-      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
-      { commandRunner: runner }
+      {
+        provider: 'claude',
+        model: 'claude-default',
+        provider_config_env: null,
+        provider_config_ref: null,
+      },
+      { commandRunner: runner },
     );
     await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
-      code: 'unsupported_agent_provider'
+      code: 'unsupported_agent_provider',
     });
   });
 
   it('GIVEN_command_exits_with_generic_nonzero_code_WHEN_executeCommand_called_THEN_throws_internal_error', async () => {
     const runner = {
-      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: undefined }))
+      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: undefined })),
     };
     const provider = new NullWorkerProvider(
-      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
-      { commandRunner: runner }
+      {
+        provider: 'claude',
+        model: 'claude-default',
+        provider_config_env: null,
+        provider_config_ref: null,
+      },
+      { commandRunner: runner },
     );
     await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
-      code: 'internal_error'
+      code: 'internal_error',
     });
   });
 
   it('GIVEN_provider_without_send_command_WHEN_executeCommand_invoked_THEN_would_throw_if_called', () => {
-    const provider = new NullWorkerProvider(
-      { provider: 'custom', model: 'custom-default', provider_config_env: null, provider_config_ref: null }
-    );
+    const provider = new NullWorkerProvider({
+      provider: 'custom',
+      model: 'custom-default',
+      provider_config_env: null,
+      provider_config_ref: null,
+    });
     // sendMessage should be undefined for custom provider without agent_config
     expect(provider.sendMessage).toBeUndefined();
   });
@@ -423,7 +514,10 @@ describe('NullWorkerProvider executeCommand error branches', () => {
 describe('NullWorkerProvider additional coverage', () => {
   it('GIVEN_empty_sessionId_WHEN_reattachSession_called_THEN_returns_null', async () => {
     const provider = new NullWorkerProvider({
-      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+      provider: 'claude',
+      model: 'claude-default',
+      provider_config_env: null,
+      provider_config_ref: null,
     });
     const result = await provider.reattachSession('');
     expect(result).toBeNull();
@@ -431,7 +525,10 @@ describe('NullWorkerProvider additional coverage', () => {
 
   it('GIVEN_unknown_sessionId_WHEN_reattachSession_called_THEN_returns_null', async () => {
     const provider = new NullWorkerProvider({
-      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+      provider: 'claude',
+      model: 'claude-default',
+      provider_config_env: null,
+      provider_config_ref: null,
     });
     const result = await provider.reattachSession('unknown');
     expect(result).toBeNull();
@@ -439,7 +536,10 @@ describe('NullWorkerProvider additional coverage', () => {
 
   it('GIVEN_valid_sessionId_WHEN_reattachSession_called_THEN_returns_worker_session', async () => {
     const provider = new NullWorkerProvider({
-      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+      provider: 'claude',
+      model: 'claude-default',
+      provider_config_env: null,
+      provider_config_ref: null,
     });
     const result = await provider.reattachSession('session-abc-1');
     expect(result).toMatchObject({ session_id: 'session-abc-1', role: 'orchestrator' });
@@ -450,13 +550,16 @@ describe('NullWorkerProvider additional coverage', () => {
     const runner = { run: vi.fn() };
     const provider = new NullWorkerProvider(
       {
-        provider: 'custom', model: 'custom', provider_config_env: null, provider_config_ref: null,
+        provider: 'custom',
+        model: 'custom',
+        provider_config_env: null,
+        provider_config_ref: null,
         agent_config: {
           send_command: 'my-cli',
-          send_args: ['send', '--session', '{session_id}', '--msg', '{message}']
-        }
+          send_args: ['send', '--session', '{session_id}', '--msg', '{message}'],
+        },
       },
-      { commandRunner: runner }
+      { commandRunner: runner },
     );
     // attachToSession should be undefined (no attach_command in config)
     expect(provider.attachToSession).toBeUndefined();
@@ -471,10 +574,10 @@ describe('resolveConfiguredAgentConfig branches', () => {
       agentsConfig: {
         runtime: {
           provider_configs: {
-            custom: { command: 'my-cli', args: ['--agent'] }
-          }
-        }
-      }
+            custom: { command: 'my-cli', args: ['--agent'] },
+          },
+        },
+      },
     });
     expect(selection.agent_config).toMatchObject({ command: 'my-cli' });
   });
@@ -486,9 +589,9 @@ describe('resolveConfiguredAgentConfig branches', () => {
       agentsConfig: {
         runtime: {
           provider_configs: {},
-          default_agent_config: { command: 'default-cli', args: [] }
-        }
-      }
+          default_agent_config: { command: 'default-cli', args: [] },
+        },
+      },
     });
     expect(selection.agent_config).toMatchObject({ command: 'default-cli' });
   });
@@ -498,8 +601,8 @@ describe('resolveConfiguredAgentConfig branches', () => {
       cli: { agent_provider: 'custom' },
       env: {},
       agentsConfig: {
-        runtime: {}
-      }
+        runtime: {},
+      },
     });
     expect(selection.agent_config).toBeNull();
   });
@@ -514,8 +617,8 @@ describe('NullWorkerProvider getSessionInfo branch', () => {
       provider_config_ref: null,
       agent_config: {
         attach_command: 'claude-code',
-        attach_args: ['chat', '--session', '{session_id}']
-      }
+        attach_args: ['chat', '--session', '{session_id}'],
+      },
     });
 
     expect(provider.getSessionInfo).toBeDefined();
@@ -532,8 +635,8 @@ describe('NullWorkerProvider getSessionInfo branch', () => {
       provider_config_ref: null,
       agent_config: {
         attach_command: 'claude-code',
-        attach_args: ['chat', '--session', '{session_id}']
-      }
+        attach_args: ['chat', '--session', '{session_id}'],
+      },
     });
 
     const info = await provider.getSessionInfo('unknown');
@@ -545,15 +648,16 @@ describe('NullWorkerProvider getSessionInfo branch', () => {
       provider: 'null',
       model: 'none',
       provider_config_env: null,
-      provider_config_ref: null
+      provider_config_ref: null,
     });
 
     // Access executeCommand directly to cover the !template guard
     await expect(
-      (provider as never as { executeCommand: (kind: string, sessionId: string) => Promise<void> })
-        .executeCommand('attach', 'session-123')
+      (
+        provider as never as { executeCommand: (kind: string, sessionId: string) => Promise<void> }
+      ).executeCommand('attach', 'session-123'),
     ).rejects.toMatchObject({
-      code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER
+      code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
     });
   });
 });