agentic-orchestrator 0.1.0

package/apps/control-plane/test/epoch-tracking.spec.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AopKernel } from '../src/core/kernel.js';
+import { makeTempRepo } from './helpers.js';
+
+describe('Orchestrator Epoch Tracking and Recovery', () => {
+  let tempDir: string;
+  let kernel: AopKernel;
+
+  beforeEach(async () => {
+    tempDir = await makeTempRepo(process.cwd());
+    kernel = new AopKernel(tempDir);
+    await kernel.ensureLoaded();
+  });
+
+  it('should initialize epoch to 0 on first run lease acquisition', async () => {
+    const result = await kernel.acquireRunLease({
+      run_id: 'test-run-1',
+      owner_instance_id: 'test-owner-1',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: false
+    });
+
+    expect(result.data.runtime_sessions.orchestrator_epoch).toBe(0);
+    expect(result.data.took_over_stale).toBe(false);
+  });
+
+  it('should maintain epoch on same owner lease renewal', async () => {
+    await kernel.acquireRunLease({
+      run_id: 'test-run-2',
+      owner_instance_id: 'test-owner-2',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: false
+    });
+
+    const renewResult = await kernel.renewRunLease('test-run-2', 'test-owner-2');
+    expect(renewResult.data.lease_expires_at).toBeDefined();
+
+    const sessions = await kernel.getRuntimeSessions();
+    expect(sessions.orchestrator_epoch).toBe(0);
+  });
+
+  it('should increment epoch when updating orchestrator session with increment flag', async () => {
+    await kernel.acquireRunLease({
+      run_id: 'test-run-3',
+      owner_instance_id: 'test-owner-3',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: false
+    });
+
+    await kernel.updateOrchestratorSession({
+      run_id: 'test-run-3',
+      owner_instance_id: 'test-owner-3',
+      orchestrator_session_id: 'new-orch-session-1',
+      increment_epoch: true
+    });
+
+    const sessions = await kernel.getRuntimeSessions();
+    expect(sessions.orchestrator_epoch).toBe(1);
+  });
+
+  it('should not increment epoch when updating without increment flag', async () => {
+    await kernel.acquireRunLease({
+      run_id: 'test-run-4',
+      owner_instance_id: 'test-owner-4',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: false
+    });
+
+    await kernel.updateOrchestratorSession({
+      run_id: 'test-run-4',
+      owner_instance_id: 'test-owner-4',
+      orchestrator_session_id: 'new-orch-session-2',
+      increment_epoch: false
+    });
+
+    const sessions = await kernel.getRuntimeSessions();
+    expect(sessions.orchestrator_epoch).toBe(0);
+  });
+
+  it('should preserve epoch on takeover', async () => {
+    await kernel.acquireRunLease({
+      run_id: 'test-run-5',
+      owner_instance_id: 'test-owner-5a',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: false
+    });
+
+    await kernel.updateOrchestratorSession({
+      run_id: 'test-run-5',
+      owner_instance_id: 'test-owner-5a',
+      orchestrator_session_id: 'orch-session-5',
+      increment_epoch: true
+    });
+
+    const index = await kernel.readIndex();
+    index.runtime_sessions.lease_expires_at = new Date(Date.now() - 60000).toISOString();
+    await kernel.writeIndex(index);
+
+    const takeoverResult = await kernel.acquireRunLease({
+      run_id: 'test-run-5-takeover',
+      owner_instance_id: 'test-owner-5b',
+      provider: 'custom',
+      model: 'test-model',
+      provider_config_ref_hash: 'hash123',
+      takeover_stale_run: true
+    });
+
+    expect(takeoverResult.data.took_over_stale).toBe(true);
+    expect(takeoverResult.data.runtime_sessions.orchestrator_epoch).toBe(1);
+  });
+});

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

@@ -0,0 +1,452 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const runCommandMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../src/core/git.js', () => ({
+  runCommand: runCommandMock
+}));
+
+import { parseCoverage, runGateMode } from '../src/core/gates.js';
+
+const basePolicy = {
+  execution: {
+    retry_policy: {
+      transient_max_retries: 1,
+      transient_error_codes: [124]
+    },
+    env_allowlist: ['TEST_ALLOWED_ENV'],
+    default_step_timeout_seconds: 1
+  },
+  testing: {
+    coverage: {
+      minimums: { line: 0.9, branch: 0.9 },
+      targets: { line: 1.0, branch: 1.0 }
+    }
+  }
+};
+
+describe('gates helpers', () => {
+  let tempRoot: string;
+
+  beforeEach(async () => {
+    tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-gates-'));
+    process.env.TEST_ALLOWED_ENV = 'allowed-value';
+    runCommandMock.mockReset();
+  });
+
+  afterEach(() => {
+    delete process.env.TEST_ALLOWED_ENV;
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_no_parser_or_none_parser_WHEN_parsing_coverage_THEN_returns_null', async () => {
+    await expect(parseCoverage(undefined, tempRoot)).resolves.toBeNull();
+    await expect(parseCoverage({ type: 'none' }, tempRoot)).resolves.toBeNull();
+  });
+
+  it('GIVEN_supported_parser_formats_WHEN_parsing_coverage_THEN_extracts_metrics', async () => {
+    await fs.writeFile(
+      path.join(tempRoot, 'lcov.info'),
+      ['TN:', 'SF:src/a.ts', 'LF:10', 'LH:8', 'BRF:4', 'BRH:3', 'end_of_record', ''].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(tempRoot, 'junit.xml'),
+      '<testsuite tests="5" failures="1" errors="1"></testsuite>',
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(tempRoot, 'jacoco.xml'),
+      '<report><counter type="LINE" missed="2" covered="8"/><counter type="BRANCH" missed="3" covered="9"/></report>',
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(tempRoot, 'cobertura.xml'),
+      '<coverage line-rate="0.75" branch-rate="0.5"></coverage>',
+      'utf8'
+    );
+
+    await expect(parseCoverage({ type: 'lcov', path: 'lcov.info' }, tempRoot)).resolves.toMatchObject({
+      line: 0.8,
+      branch: 0.75,
+      details: { linesFound: 10, linesHit: 8, branchesFound: 4, branchesHit: 3 }
+    });
+    await expect(parseCoverage({ type: 'junit_xml', path: 'junit.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 0.6,
+      branch: 0.6
+    });
+    await expect(parseCoverage({ type: 'jacoco_xml', path: 'jacoco.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 0.8,
+      branch: 0.75
+    });
+    await expect(parseCoverage({ type: 'cobertura_xml', path: 'cobertura.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 0.75,
+      branch: 0.5
+    });
+  });
+
+  it('GIVEN_unsupported_parser_WHEN_parsing_coverage_THEN_throws_error', async () => {
+    await fs.writeFile(path.join(tempRoot, 'raw.txt'), 'x', 'utf8');
+    await expect(parseCoverage({ type: 'custom_parser', path: 'raw.txt' }, tempRoot)).rejects.toThrow(
+      'unsupported_parser:custom_parser'
+    );
+  });
+
+  it('GIVEN_missing_mode_definition_WHEN_running_gate_mode_THEN_throws_unknown_mode_error', async () => {
+    await expect(
+      runGateMode({
+        featureId: 'feature_a',
+        mode: 'fast',
+        profileName: 'default',
+        profile: { modes: {} },
+        policy: basePolicy as any,
+        worktreePath: tempRoot,
+        logDirectory: path.join(tempRoot, 'logs'),
+        evidenceDirectory: path.join(tempRoot, 'evidence')
+      })
+    ).rejects.toThrow('unknown_gate_profile_or_mode:default/fast');
+  });
+
+  it('GIVEN_transient_failure_then_success_WHEN_running_gate_mode_THEN_retries_and_passes', async () => {
+    runCommandMock
+      .mockResolvedValueOnce({
+        code: 124,
+        signal: null,
+        stdout: '',
+        stderr: 'timeout',
+        timeout: false
+      })
+      .mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: 'ok',
+        stderr: '',
+        timeout: false
+      });
+
+    const result = await runGateMode({
+      featureId: 'feature_a',
+      mode: 'fast',
+      profileName: 'default',
+      profile: {
+        modes: {
+          fast: [
+            {
+              name: 'lint',
+              cmd: ['npm', 'run', 'lint'],
+              env: { EXTRA: '1' },
+              timeout_seconds: 2
+            }
+          ]
+        },
+        parsers: { coverage: { type: 'none' } }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(result.overall).toBe('pass');
+    expect(result.coverage_status).toBe('na');
+    expect(result.step_results).toEqual([
+      expect.objectContaining({
+        name: 'lint',
+        attempts: 2,
+        exit_code: 0,
+        timeout: false
+      })
+    ]);
+    expect(runCommandMock).toHaveBeenCalledTimes(2);
+
+    const firstCallOptions = runCommandMock.mock.calls[0][2];
+    expect(firstCallOptions.timeoutMs).toBe(2000);
+    expect(firstCallOptions.env).toMatchObject({
+      TEST_ALLOWED_ENV: 'allowed-value',
+      EXTRA: '1'
+    });
+
+    await expect(fs.stat(result.evidence_path as string)).resolves.toBeTruthy();
+    await expect(fs.stat(result.latest_path as string)).resolves.toBeTruthy();
+  });
+
+  it('GIVEN_non_transient_failure_WHEN_running_gate_mode_THEN_fails_without_extra_retries', async () => {
+    runCommandMock.mockResolvedValue({
+      code: 2,
+      signal: null,
+      stdout: '',
+      stderr: 'bad command',
+      timeout: false
+    });
+
+    const result = await runGateMode({
+      featureId: 'feature_a',
+      mode: 'fast',
+      profileName: 'default',
+      profile: {
+        modes: {
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
+        }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(result.overall).toBe('fail');
+    expect(result.step_results).toEqual([
+      expect.objectContaining({
+        attempts: 1,
+        exit_code: 2
+      })
+    ]);
+    expect(runCommandMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('GIVEN_timeout_or_exhausted_transient_retries_WHEN_running_gate_mode_THEN_fails', async () => {
+    runCommandMock.mockResolvedValue({
+      code: 124,
+      signal: null,
+      stdout: '',
+      stderr: 'timeout',
+      timeout: true
+    });
+
+    const timeoutResult = await runGateMode({
+      featureId: 'feature_timeout',
+      mode: 'fast',
+      profileName: 'default',
+      profile: {
+        modes: {
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
+        }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(timeoutResult.overall).toBe('fail');
+    expect(timeoutResult.step_results[0]).toMatchObject({ attempts: 1, timeout: true });
+
+    runCommandMock.mockReset();
+    runCommandMock
+      .mockResolvedValueOnce({
+        code: 124,
+        signal: null,
+        stdout: '',
+        stderr: 'timeout',
+        timeout: false
+      })
+      .mockResolvedValueOnce({
+        code: 124,
+        signal: null,
+        stdout: '',
+        stderr: 'timeout',
+        timeout: false
+      });
+
+    const exhaustedRetries = await runGateMode({
+      featureId: 'feature_retry',
+      mode: 'fast',
+      profileName: 'default',
+      profile: {
+        modes: {
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
+        }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(exhaustedRetries.overall).toBe('fail');
+    expect(exhaustedRetries.step_results[0]).toMatchObject({ attempts: 2, exit_code: 124 });
+  });
+
+  it('GIVEN_missing_or_high_coverage_artifacts_WHEN_running_gate_mode_THEN_sets_expected_coverage_status', async () => {
+    runCommandMock.mockResolvedValue({
+      code: 0,
+      signal: null,
+      stdout: 'ok',
+      stderr: '',
+      timeout: false
+    });
+
+    const missingCoverage = await runGateMode({
+      featureId: 'feature_no_cov',
+      mode: 'full',
+      profileName: 'default',
+      profile: {
+        modes: {
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+        },
+        parsers: { coverage: { type: 'lcov', path: 'missing/lcov.info' } }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+    expect(missingCoverage.overall).toBe('pass');
+    expect(missingCoverage.coverage_status).toBe('na');
+
+    const coverageDir = path.join(tempRoot, 'coverage-pass');
+    await fs.mkdir(coverageDir, { recursive: true });
+    await fs.writeFile(
+      path.join(coverageDir, 'lcov.info'),
+      ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:20', 'BRF:10', 'BRH:10', 'end_of_record', ''].join('\n'),
+      'utf8'
+    );
+
+    const highCoverage = await runGateMode({
+      featureId: 'feature_cov_pass',
+      mode: 'full',
+      profileName: 'default',
+      profile: {
+        modes: {
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+        },
+        parsers: { coverage: { type: 'lcov', path: 'coverage-pass/lcov.info' } },
+        thresholds: {
+          coverage_line_min: 0.5,
+          coverage_branch_min: 0.5
+        }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+    expect(highCoverage.overall).toBe('pass');
+    expect(highCoverage.coverage_status).toBe('pass');
+    expect(highCoverage.thresholds).toMatchObject({
+      coverage_line_min: 0.9,
+      coverage_branch_min: 0.9
+    });
+  });
+
+  it('GIVEN_low_coverage_WHEN_running_gate_mode_THEN_marks_coverage_failure', async () => {
+    const coverageDir = path.join(tempRoot, 'coverage');
+    await fs.mkdir(coverageDir, { recursive: true });
+    await fs.writeFile(
+      path.join(coverageDir, 'lcov.info'),
+      ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:10', 'BRF:10', 'BRH:3', 'end_of_record', ''].join('\n'),
+      'utf8'
+    );
+
+    runCommandMock.mockResolvedValue({
+      code: 0,
+      signal: null,
+      stdout: 'ok',
+      stderr: '',
+      timeout: false
+    });
+
+    const result = await runGateMode({
+      featureId: 'feature_cov',
+      mode: 'full',
+      profileName: 'default',
+      profile: {
+        modes: {
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+        },
+        parsers: { coverage: { type: 'lcov', path: 'coverage/lcov.info' } }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(result.overall).toBe('fail');
+    expect(result.coverage_status).toBe('fail');
+    expect(result.coverage).toMatchObject({
+      line: 0.5,
+      branch: 0.3
+    });
+
+    const latest = JSON.parse(await fs.readFile(result.latest_path as string, 'utf8'));
+    expect(latest.coverage_failure).toMatchObject({
+      line: 0.5,
+      branch: 0.3,
+      min_line: 0.9,
+      min_branch: 0.9
+    });
+  });
+
+  it('GIVEN_sparse_coverage_artifacts_WHEN_parsing_THEN_uses_safe_default_metrics', async () => {
+    await fs.writeFile(path.join(tempRoot, 'lcov-empty.info'), 'TN:\nSF:src/a.ts\nend_of_record\n', 'utf8');
+    await fs.writeFile(path.join(tempRoot, 'junit-empty.xml'), '<testsuite></testsuite>', 'utf8');
+    await fs.writeFile(path.join(tempRoot, 'jacoco-empty.xml'), '<report></report>', 'utf8');
+    await fs.writeFile(path.join(tempRoot, 'cobertura-empty.xml'), '<coverage></coverage>', 'utf8');
+
+    await expect(parseCoverage({ type: 'lcov', path: 'lcov-empty.info' }, tempRoot)).resolves.toMatchObject({
+      line: 1,
+      branch: 1,
+      details: { linesFound: 0, linesHit: 0, branchesFound: 0, branchesHit: 0 }
+    });
+    await expect(parseCoverage({ type: 'junit_xml', path: 'junit-empty.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 1,
+      branch: 1
+    });
+    await expect(parseCoverage({ type: 'jacoco_xml', path: 'jacoco-empty.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 1,
+      branch: 1,
+      details: { lineMissed: 0, lineCovered: 0, branchMissed: 0, branchCovered: 0 }
+    });
+    await expect(parseCoverage({ type: 'cobertura_xml', path: 'cobertura-empty.xml' }, tempRoot)).resolves.toMatchObject({
+      line: 1,
+      branch: 1,
+      details: { lineRate: 1, branchRate: 1 }
+    });
+  });
+
+  it('GIVEN_parser_without_path_or_step_cwd_WHEN_running_parsing_or_gate_THEN_uses_defaults', async () => {
+    const standaloneLcov = path.join(tempRoot, 'standalone.lcov');
+    await fs.writeFile(
+      standaloneLcov,
+      ['TN:', 'SF:src/a.ts', 'LF:2', 'LH:1', 'BRF:2', 'BRH:1', 'end_of_record', ''].join('\n'),
+      'utf8'
+    );
+    await expect(parseCoverage({ type: 'lcov' }, standaloneLcov)).resolves.toMatchObject({
+      line: 0.5,
+      branch: 0.5
+    });
+
+    runCommandMock.mockResolvedValue({
+      code: 0,
+      signal: null,
+      stdout: 'ok',
+      stderr: '',
+      timeout: false
+    });
+
+    const result = await runGateMode({
+      featureId: 'feature_cwd',
+      mode: 'fast',
+      profileName: 'default',
+      profile: {
+        modes: {
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'], cwd: 'packages/app' }]
+        },
+        parsers: { coverage: { type: 'none' } }
+      },
+      policy: basePolicy as any,
+      worktreePath: tempRoot,
+      logDirectory: path.join(tempRoot, 'logs'),
+      evidenceDirectory: path.join(tempRoot, 'evidence')
+    });
+
+    expect(result.overall).toBe('pass');
+    expect(runCommandMock.mock.calls[0]?.[2]).toMatchObject({
+      cwd: path.join(tempRoot, 'packages/app')
+    });
+  });
+});

package/apps/control-plane/test/helpers.ts

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { stableHash } from '../src/core/fs.js';
+import { runCommand } from '../src/core/git.js';
+
+export async function makeTempRepo(templateRoot) {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-test-'));
+  await fs.cp(path.join(templateRoot, 'agentic'), path.join(tempRoot, 'agentic'), { recursive: true });
+  await fs.cp(path.join(templateRoot, 'apps'), path.join(tempRoot, 'apps'), { recursive: true });
+  await fs.writeFile(path.join(tempRoot, 'README.md'), '# temp repo\n', 'utf8');
+
+  // Runtime artifacts are generated under .aop and should not come from the template copy.
+  await fs.rm(path.join(tempRoot, '.aop', 'features'), { recursive: true, force: true });
+  await fs.rm(path.join(tempRoot, '.aop', 'runtime'), { recursive: true, force: true });
+
+  await fs.mkdir(path.join(tempRoot, '.aop', 'features'), { recursive: true });
+  await fs.mkdir(path.join(tempRoot, '.aop', 'runtime', 'operation-ledger'), { recursive: true });
+
+  const indexPath = path.join(tempRoot, '.aop', 'features', 'index.json');
+  const now = new Date().toISOString();
+  await fs.writeFile(
+    indexPath,
+    `${JSON.stringify(
+      {
+        version: 1,
+        active: [],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {},
+        blocked_queue: [],
+        updated_at: now,
+        runtime_sessions: {
+          run_id: 'none',
+          orchestrator_session_id: 'unknown',
+          provider: 'unknown',
+          model: 'unknown',
+          provider_config_ref_hash: stableHash('none'),
+          owner_instance_id: 'none',
+          lease_id: 'none',
+          started_at: now,
+          last_heartbeat_at: now,
+          lease_expires_at: now,
+          orchestrator_epoch: 0,
+          feature_sessions: {}
+        }
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+
+  await runCommand('git', ['init', '-b', 'main'], { cwd: tempRoot });
+  await runCommand('git', ['config', 'user.email', 'test@example.com'], { cwd: tempRoot });
+  await runCommand('git', ['config', 'user.name', 'AOP Test'], { cwd: tempRoot });
+  await runCommand('git', ['add', '.'], { cwd: tempRoot });
+  await runCommand('git', ['commit', '-m', 'initial'], { cwd: tempRoot });
+
+  return tempRoot;
+}
+
+export async function writeFeatureSpec(repoRoot, featureId, content = '# Spec\n\nBuild something.\n') {
+  const featureDir = path.join(repoRoot, '.aop', 'features', featureId);
+  await fs.mkdir(featureDir, { recursive: true });
+  await fs.writeFile(path.join(featureDir, 'spec.md'), content, 'utf8');
+}

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

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import * as api from '../src/index.js';
+
+describe('public index exports', () => {
+  it('GIVEN_module_import_WHEN_loaded_THEN_exposes_public_api_symbols', () => {
+    expect(typeof api.AopKernel).toBe('function');
+    expect(typeof api.SupervisorRuntime).toBe('function');
+    expect(typeof api.resolveProviderSelection).toBe('function');
+    expect(typeof api.NullWorkerProvider).toBe('function');
+    expect(typeof api.createToolingRuntime).toBe('function');
+    expect(typeof api.resolveToolClient).toBe('function');
+    expect(typeof api.InProcessToolClient).toBe('function');
+    expect(typeof api.McpToolClient).toBe('function');
+    expect(typeof api.createOperationId).toBe('function');
+    expect(typeof api.TokenAuthVerifier).toBe('function');
+    expect(typeof api.McpServerAdapter).toBe('function');
+  });
+});