import { a as MultiAgentOrchestrator, M as MultiAgentOrchestratorOptions, l as AgentOrchestrator, O as OrchestratorOptions, H as HealthMonitor, K as MultiplexedStreamChunk, i as DebugTimeline, aa as TaskRegistration, Y as ReflectionEvaluator } from './orchestrator-types-D6gzobwg.js';
import { z as ApprovalRequest, L as BreakpointModifications, I as InputGuardrailData, O as OutputGuardrailData, M as Message, T as ToolCallGuardrailData, b2 as ToolCall, ah as GuardrailResult, A as AgentLike, b as AgentRunner, p as RunOptions, N as BreakpointRequest, W as Checkpoint, h as DagExecutionContext, a3 as DagNodeStatus, aN as RerouteEvent, aS as Scratchpad, a8 as DebugEventType, e as CheckpointStore, an as InMemoryCheckpointStore, D as DagNode, i as DagPattern, q as DebugEvent, G as GuardrailFn, ae as GuardrailContext } from './types-CRmwFnVk.js';
import '@directive-run/core';
import '@directive-run/core/plugins';

/**
 * Directive AI Testing Utilities
 *
 * Provides testing helpers for:
 * - Mock agent runners with configurable responses
 * - Guardrail testing with assertions
 * - Approval workflow simulation
 * - Snapshot testing for constraint evaluation
 *
 * @example
 * ```typescript
 * import { createMockAgentRunner, testGuardrail, createApprovalSimulator } from '@directive-run/ai/testing';
 *
 * describe('MyOrchestrator', () => {
 *   it('should block PII in input', async () => {
 *     const result = await testGuardrail(createPIIGuardrail(), {
 *       input: 'My SSN is 123-45-6789',
 *     });
 *     expect(result.passed).toBe(false);
 *     expect(result.reason).toContain('PII');
 *   });
 * });
 * ```
 */

/** Configuration for mock agent responses */
interface MockAgentConfig<T = unknown> {
    /** Final output to return */
    output: T;
    /** Messages to emit during run */
    messages?: Message[];
    /** Tool calls to emit during run */
    toolCalls?: ToolCall[];
    /** Total tokens to report */
    totalTokens?: number;
    /** Delay before responding (ms) */
    delay?: number;
    /** Error to throw instead of returning */
    error?: Error;
    /** Function to generate dynamic responses */
    generate?: (input: string, agent: AgentLike) => Partial<MockAgentConfig<T>>;
}
/** Mock agent runner options */
interface MockAgentRunnerOptions {
    /** Default response for unmatched agents */
    defaultResponse?: MockAgentConfig;
    /** Responses keyed by agent name */
    responses?: Record<string, MockAgentConfig>;
    /** Record all calls for assertions */
    recordCalls?: boolean;
    /** Callback for each run */
    onRun?: (agent: AgentLike, input: string) => void;
}
/** Recorded call for assertions */
interface RecordedCall {
    agent: AgentLike;
    input: string;
    options?: RunOptions;
    timestamp: number;
}
/** Mock agent runner instance */
interface MockAgentRunner {
    /** The run function to pass to orchestrator */
    run: AgentRunner;
    /** Get all recorded calls */
    getCalls(): RecordedCall[];
    /** Get calls for a specific agent */
    getCallsFor(agentName: string): RecordedCall[];
    /** Clear recorded calls */
    clearCalls(): void;
    /** Set response for an agent */
    setResponse<T>(agentName: string, config: MockAgentConfig<T>): void;
    /** Set default response */
    setDefaultResponse<T>(config: MockAgentConfig<T>): void;
}
/**
 * Create a mock agent runner for testing.
 *
 * @example
 * ```typescript
 * const mock = createMockAgentRunner({
 *   responses: {
 *     'my-agent': {
 *       output: 'Hello, world!',
 *       totalTokens: 100,
 *     },
 *   },
 * });
 *
 * const orchestrator = createAgentOrchestrator({ runner: mock.run });
 * const result = await orchestrator.run(myAgent, 'Hi');
 *
 * expect(result.output).toBe('Hello, world!');
 * expect(mock.getCalls()).toHaveLength(1);
 * ```
 */
declare function createMockAgentRunner(options?: MockAgentRunnerOptions): MockAgentRunner;
/** Test input for guardrail testing */
type GuardrailTestInput<T> = T extends InputGuardrailData ? {
    input: string;
    agentName?: string;
} : T extends OutputGuardrailData ? {
    output: unknown;
    agentName?: string;
    input?: string;
    messages?: Message[];
} : T extends ToolCallGuardrailData ? {
    toolCall: ToolCall;
    agentName?: string;
    input?: string;
} : Partial<T>;
/** Extended guardrail result with test assertions */
interface GuardrailTestResult extends GuardrailResult {
    /** Time taken to evaluate (ms) */
    duration: number;
    /** The data that was tested */
    testedData: unknown;
    /** Assert that the guardrail passed */
    assertPassed(): void;
    /** Assert that the guardrail failed */
    assertFailed(expectedReason?: string | RegExp): void;
    /** Assert that transformation occurred */
    assertTransformed(expected?: unknown): void;
}
/**
 * Test a guardrail with assertions.
 *
 * @example
 * ```typescript
 * // Test PII detection
 * const result = await testGuardrail(createPIIGuardrail(), {
 *   input: 'My SSN is 123-45-6789',
 * });
 * result.assertFailed(/PII/);
 *
 * // Test input transformation
 * const redactResult = await testGuardrail(createPIIGuardrail({ redact: true }), {
 *   input: 'My SSN is 123-45-6789',
 * });
 * redactResult.assertPassed();
 * redactResult.assertTransformed();
 * ```
 */
declare function testGuardrail<T>(guardrail: GuardrailFn<T>, testInput: GuardrailTestInput<T>, context?: Partial<GuardrailContext>): Promise<GuardrailTestResult>;
/**
 * Test multiple inputs against a guardrail.
 *
 * @example
 * ```typescript
 * const results = await testGuardrailBatch(createPIIGuardrail(), [
 *   { input: 'Hello world', expect: 'pass' },
 *   { input: 'My SSN is 123-45-6789', expect: 'fail' },
 *   { input: 'Email: test@example.com', expect: 'fail' },
 * ]);
 *
 * expect(results.allPassed()).toBe(true);
 * ```
 */
declare function testGuardrailBatch<T>(guardrail: GuardrailFn<T>, testCases: Array<{
    input: GuardrailTestInput<T>;
    expect: "pass" | "fail" | "transform";
    context?: Partial<GuardrailContext>;
}>): Promise<{
    results: GuardrailTestResult[];
    allPassed(): boolean;
    failures(): Array<{
        index: number;
        expected: string;
        actual: GuardrailTestResult;
    }>;
}>;
/** Approval simulator options */
interface ApprovalSimulatorOptions {
    /** Auto-approve requests matching this predicate */
    autoApprove?: (request: ApprovalRequest) => boolean;
    /** Auto-reject requests matching this predicate */
    autoReject?: (request: ApprovalRequest) => boolean | string;
    /** Delay before auto-approval/rejection (ms) */
    delay?: number;
    /** Record all requests for assertions */
    recordRequests?: boolean;
}
/** Approval simulator instance */
interface ApprovalSimulator {
    /** Handle an approval request */
    handle(request: ApprovalRequest): Promise<"approved" | "rejected">;
    /** Get all recorded requests */
    getRequests(): ApprovalRequest[];
    /** Clear recorded requests */
    clearRequests(): void;
    /** Manually approve a request */
    approve(requestId: string): void;
    /** Manually reject a request */
    reject(requestId: string, reason?: string): void;
    /** Wait for a specific request */
    waitForRequest(predicate: (req: ApprovalRequest) => boolean, timeoutMs?: number): Promise<ApprovalRequest>;
}
/**
 * Create an approval simulator for testing approval workflows.
 *
 * @example
 * ```typescript
 * const simulator = createApprovalSimulator({
 *   autoApprove: (req) => req.type === 'tool_call' && req.data.name === 'search',
 *   autoReject: (req) => req.type === 'tool_call' && req.data.name === 'delete',
 * });
 *
 * // Use in tests
 * orchestrator.onApprovalRequest = (req) => simulator.handle(req);
 * ```
 */
declare function createApprovalSimulator(options?: ApprovalSimulatorOptions): ApprovalSimulator;
/** Options for test orchestrator */
interface TestOrchestratorOptions<F extends Record<string, unknown>> extends Omit<OrchestratorOptions<F>, "runner"> {
    /** Mock responses for agents */
    mockResponses?: Record<string, MockAgentConfig>;
    /** Default mock response */
    defaultMockResponse?: MockAgentConfig;
}
/** Test orchestrator with additional testing utilities */
interface TestOrchestrator<F extends Record<string, unknown>> extends AgentOrchestrator<F> {
    /** The mock runner */
    mockRunner: MockAgentRunner;
    /** Approval simulator */
    approvalSimulator: ApprovalSimulator;
    /** Get recorded agent calls */
    getCalls(): RecordedCall[];
    /** Get approval requests */
    getApprovalRequests(): ApprovalRequest[];
    /** Reset all state */
    resetAll(): void;
}
/**
 * Create a test orchestrator with mocking and simulation built in.
 *
 * @example
 * ```typescript
 * const test = createTestOrchestrator({
 *   mockResponses: {
 *     'my-agent': { output: 'test response' },
 *   },
 *   constraints: {
 *     needsApproval: {
 *       when: () => true,
 *       require: { type: 'NEED_APPROVAL' },
 *     },
 *   },
 * });
 *
 * await test.run(myAgent, 'Hello');
 * expect(test.getCalls()).toHaveLength(1);
 * ```
 */
declare function createTestOrchestrator<F extends Record<string, unknown> = Record<string, never>>(options?: TestOrchestratorOptions<F>): TestOrchestrator<F>;
/** Constraint evaluation snapshot */
interface ConstraintSnapshot {
    constraintId: string;
    triggered: boolean;
    requirement?: unknown;
    facts: Record<string, unknown>;
    timestamp: number;
}
/**
 * Create a constraint evaluation recorder for snapshot testing.
 *
 * @example
 * ```typescript
 * const recorder = createConstraintRecorder();
 * const orchestrator = createAgentOrchestrator({
 *   plugins: [recorder.plugin],
 * });
 *
 * await orchestrator.run(agent, 'Hello');
 *
 * expect(recorder.getSnapshots()).toMatchSnapshot();
 * ```
 */
declare function createConstraintRecorder(): {
    plugin: {
        name: string;
        onRequirementCreated: (data: {
            constraintId: string;
            requirement: unknown;
            facts: unknown;
        }) => void;
    };
    getSnapshots(): ConstraintSnapshot[];
    clearSnapshots(): void;
};
/**
 * Assert that an orchestrator has specific state.
 *
 * @example
 * ```typescript
 * assertOrchestratorState(orchestrator, {
 *   agentStatus: 'completed',
 *   tokenUsage: { min: 0, max: 1000 },
 *   pendingApprovals: 0,
 * });
 * ```
 */
declare function assertOrchestratorState<F extends Record<string, unknown>>(orchestrator: AgentOrchestrator<F>, expected: {
    agentStatus?: "idle" | "running" | "paused" | "completed" | "error";
    tokenUsage?: {
        min?: number;
        max?: number;
        exact?: number;
    };
    pendingApprovals?: number;
    conversationLength?: {
        min?: number;
        max?: number;
        exact?: number;
    };
}): void;
/**
 * Create a time controller for testing time-dependent behavior.
 *
 * @example
 * ```typescript
 * const time = createTimeController();
 *
 * // Override Date.now
 * const originalNow = Date.now;
 * Date.now = () => time.now();
 *
 * time.advance(1000); // Advance 1 second
 *
 * // Restore
 * Date.now = originalNow;
 * ```
 */
declare function createTimeController(startTime?: number): {
    now(): number;
    advance(ms: number): void;
    set(time: number): void;
    reset(): void;
};
/** Options for test multi-agent orchestrator */
interface TestMultiAgentOrchestratorOptions extends Omit<MultiAgentOrchestratorOptions, "runner"> {
    /** Mock responses keyed by agent ID — internally mapped to agent names for the mock runner */
    mockResponses?: Record<string, MockAgentConfig>;
    /** Default mock response for unmatched agents */
    defaultMockResponse?: MockAgentConfig;
    /** Mock tasks keyed by task ID — auto-generates TaskRegistration wrappers */
    mockTasks?: Record<string, {
        output: unknown;
        delay?: number;
        shouldError?: boolean;
    }>;
}
/** Test multi-agent orchestrator with additional testing utilities */
interface TestMultiAgentOrchestrator extends MultiAgentOrchestrator {
    /** The mock runner */
    mockRunner: MockAgentRunner;
    /** Approval simulator */
    approvalSimulator: ApprovalSimulator;
    /** Get recorded agent calls */
    getCalls(): RecordedCall[];
    /** Get approval requests */
    getApprovalRequests(): ApprovalRequest[];
    /** Reset all state */
    resetAll(): void;
}
/**
 * Create a test multi-agent orchestrator with mocking and simulation built in.
 *
 * @example
 * ```typescript
 * const test = createTestMultiAgentOrchestrator({
 *   agents: {
 *     researcher: { agent: { name: 'researcher' } },
 *     writer: { agent: { name: 'writer' } },
 *   },
 *   mockResponses: {
 *     researcher: { output: 'Research results', totalTokens: 100 },
 *     writer: { output: 'Written article', totalTokens: 200 },
 *   },
 * });
 *
 * const result = await test.runAgent('researcher', 'What is AI?');
 * expect(result.output).toBe('Research results');
 * expect(test.getCalls()).toHaveLength(1);
 * ```
 */
declare function createTestMultiAgentOrchestrator(options: TestMultiAgentOrchestratorOptions): TestMultiAgentOrchestrator;
/**
 * Assert that a multi-agent orchestrator has specific state.
 *
 * @example
 * ```typescript
 * assertMultiAgentState(orchestrator, {
 *   agentStatus: { researcher: 'completed', writer: 'idle' },
 *   globalTokens: { min: 0, max: 1000 },
 *   pendingHandoffs: 0,
 * });
 * ```
 */
declare function assertMultiAgentState(orchestrator: MultiAgentOrchestrator, expected: {
    agentStatus?: Record<string, "idle" | "running" | "completed" | "error">;
    taskStatus?: Record<string, string>;
    totalTokens?: {
        agentId?: string;
        min?: number;
        max?: number;
    };
    globalTokens?: {
        min?: number;
        max?: number;
    };
    pendingHandoffs?: number;
}): void;
/**
 * Create a mock TaskRegistration for testing.
 *
 * @example
 * ```typescript
 * const task = createMockTask({ result: "processed" }, { delay: 100 });
 * const orchestrator = createTestMultiAgentOrchestrator({
 *   agents: { writer: { agent: { name: "writer" } } },
 *   tasks: { process: task },
 * });
 * ```
 */
declare function createMockTask(output: unknown, options?: {
    delay?: number;
    shouldError?: boolean;
    label?: string;
    description?: string;
}): TaskRegistration;

/**
 * Create a test DAG pattern from a simplified node spec.
 *
 * @example
 * ```typescript
 * const pattern = createTestDag({
 *   A: { handler: "researcher" },
 *   B: { handler: "writer", deps: ["A"] },
 *   C: { handler: "reviewer", deps: ["B"] },
 * });
 * ```
 */
declare function createTestDag<T = unknown>(nodes: Record<string, Pick<DagNode, "handler" | "deps" | "when" | "transform" | "timeout" | "priority">>, merge?: (context: DagExecutionContext) => T | Promise<T>, options?: {
    timeout?: number;
    maxConcurrent?: number;
    onNodeError?: "fail" | "skip-downstream" | "continue";
}): DagPattern<T>;
/**
 * Assert that a DAG execution produced the expected node statuses.
 *
 * @example
 * ```typescript
 * assertDagExecution(context, {
 *   nodeStatuses: { A: "completed", B: "completed", C: "skipped" },
 *   completedNodes: ["A", "B"],
 *   skippedNodes: ["C"],
 * });
 * ```
 */
declare function assertDagExecution(context: DagExecutionContext, expected: {
    nodeStatuses?: Record<string, DagNodeStatus>;
    completedNodes?: string[];
    skippedNodes?: string[];
    errorNodes?: string[];
    outputContains?: Record<string, unknown>;
}): void;

/**
 * Create a test debug timeline pre-populated with events.
 *
 * @example
 * ```typescript
 * const timeline = createTestTimeline([
 *   { type: "agent_start", agentId: "researcher", inputLength: 42 },
 *   { type: "agent_complete", agentId: "researcher", outputLength: 100, durationMs: 500, totalTokens: 200 },
 * ]);
 *
 * expect(timeline.getEventsForAgent("researcher")).toHaveLength(2);
 * ```
 */
declare function createTestTimeline(events?: Array<Partial<DebugEvent> & {
    type: DebugEventType;
}>, options?: {
    maxEvents?: number;
}): DebugTimeline;
/**
 * Assert that a debug timeline contains expected events.
 *
 * @example
 * ```typescript
 * assertTimelineEvents(timeline, {
 *   totalEvents: 5,
 *   eventTypes: ["agent_start", "guardrail_check", "agent_complete"],
 *   agentEvents: { researcher: 3, writer: 2 },
 *   hasType: "guardrail_check",
 * });
 * ```
 */
declare function assertTimelineEvents(timeline: DebugTimeline, expected: {
    totalEvents?: number;
    minEvents?: number;
    maxEvents?: number;
    eventTypes?: DebugEventType[];
    agentEvents?: Record<string, number>;
    hasType?: DebugEventType;
    doesNotHaveType?: DebugEventType;
}): void;

/**
 * Create a runner that always fails, useful for testing self-healing.
 *
 * @example
 * ```typescript
 * const failing = createFailingRunner(new Error("Provider down"));
 * const orchestrator = createAgentOrchestrator({
 *   runner: failing,
 *   selfHealing: { fallbackRunners: [backupRunner] },
 * });
 * ```
 */
declare function createFailingRunner(error?: Error, options?: {
    delay?: number;
    failAfter?: number;
}): AgentRunner;
/**
 * Assert that an agent was rerouted during execution.
 *
 * @example
 * ```typescript
 * const events: RerouteEvent[] = [];
 * const orchestrator = createMultiAgentOrchestrator({
 *   selfHealing: {
 *     onReroute: (event) => events.push(event),
 *   },
 * });
 *
 * // ... trigger reroute ...
 * assertRerouted(events, {
 *   fromAgent: "primary",
 *   toAgent: "backup",
 *   reason: /circuit breaker/i,
 * });
 * ```
 */
declare function assertRerouted(events: RerouteEvent[], expected: {
    fromAgent?: string;
    toAgent?: string;
    reason?: string | RegExp;
    minReroutes?: number;
}): void;
/**
 * Assert the health state of an agent in the health monitor.
 *
 * @example
 * ```typescript
 * assertAgentHealth(monitor, "researcher", {
 *   minScore: 70,
 *   circuitState: "CLOSED",
 * });
 * ```
 */
declare function assertAgentHealth(monitor: HealthMonitor, agentId: string, expected: {
    minScore?: number;
    maxScore?: number;
    circuitState?: "CLOSED" | "OPEN" | "HALF_OPEN";
    minSuccessRate?: number;
}): void;
/**
 * Create a test checkpoint store (wraps InMemoryCheckpointStore with assertion helpers).
 *
 * @example
 * ```typescript
 * const store = createTestCheckpointStore();
 * const orchestrator = createAgentOrchestrator({ runner, checkpointStore: store });
 * const cp = await orchestrator.checkpoint();
 * expect(store.saved).toHaveLength(1);
 * ```
 */
declare function createTestCheckpointStore(maxCheckpoints?: number): CheckpointStore & {
    saved: Checkpoint[];
    inner: InMemoryCheckpointStore;
    /** Get the most recently saved checkpoint */
    getLatest: () => Checkpoint | undefined;
};
/**
 * Assert that a checkpoint has expected properties.
 */
declare function assertCheckpoint(checkpoint: Checkpoint, expected: {
    orchestratorType?: "single" | "multi";
    hasTimeline?: boolean;
    hasMemory?: boolean;
    hasSystemExport?: boolean;
    label?: string;
}): void;
/** Options for the breakpoint simulator */
interface BreakpointSimulatorOptions {
    /** Auto-resume after this delay (ms). Default: 0 (immediate) */
    autoResumeDelay?: number;
    /** Modifications to apply on resume */
    modifications?: BreakpointModifications;
    /** If true, cancel instead of resume */
    cancel?: boolean;
    /** Cancel reason */
    cancelReason?: string;
}
/**
 * Create a breakpoint simulator that auto-resolves breakpoints.
 *
 * @example
 * ```typescript
 * const simulator = createBreakpointSimulator({ autoResumeDelay: 10 });
 * const orchestrator = createAgentOrchestrator({
 *   runner,
 *   breakpoints: [{ type: "pre_agent_run" }],
 *   onBreakpoint: simulator.handler,
 * });
 * // Run agent — breakpoint fires and auto-resumes
 * await orchestrator.run("test input");
 * expect(simulator.hits).toHaveLength(1);
 * ```
 */
/** Minimal interface for breakpoint-capable orchestrators */
interface BreakpointCapable {
    resumeBreakpoint(id: string, modifications?: BreakpointModifications): void;
    cancelBreakpoint(id: string, reason?: string): void;
}
/**
 * Create a breakpoint simulator that auto-resolves breakpoints for testing.
 *
 * @param options - Simulator options including `autoResumeDelay` and `modifications`.
 * @returns An object with `handler`, `hits`, and `attachTo` for test assertions.
 */
declare function createBreakpointSimulator(options?: BreakpointSimulatorOptions): {
    handler: (request: BreakpointRequest) => void;
    hits: BreakpointRequest[];
    attachTo: (orchestrator: BreakpointCapable) => void;
};
/**
 * Assert that a breakpoint was hit with expected properties.
 */
declare function assertBreakpointHit(hits: BreakpointRequest[], expected: {
    type?: string;
    agentId?: string;
    count?: number;
}): void;
/**
 * Create a mock SafeParseable schema for testing.
 *
 * @example
 * ```typescript
 * const schema = createMockSchema((data) => typeof data === "object" && data !== null);
 * const orchestrator = createAgentOrchestrator({
 *   runner,
 *   outputSchema: schema,
 * });
 * ```
 */
declare function createMockSchema<T>(validate: (data: unknown) => boolean, description?: string): {
    safeParse: (data: unknown) => {
        success: boolean;
        data?: T;
        error?: {
            message: string;
        };
    };
    description?: string;
};
/**
 * Collect all chunks from a multiplexed stream into an array.
 *
 * @example
 * ```typescript
 * const { stream } = orchestrator.runParallelStream(["a", "b"], "input", merge);
 * const chunks = await collectMultiplexedStream(stream);
 * expect(chunks.length).toBeGreaterThan(0);
 * ```
 */
declare function collectMultiplexedStream(stream: AsyncIterable<MultiplexedStreamChunk>): Promise<MultiplexedStreamChunk[]>;
/**
 * Assert properties of collected multiplexed stream chunks.
 */
declare function assertMultiplexedStream(chunks: MultiplexedStreamChunk[], expected: {
    agentIds?: string[];
    minChunks?: number;
    hasDone?: boolean;
    hasErrors?: boolean;
}): void;
/**
 * Create a test reflection evaluator that passes after N iterations.
 *
 * @example
 * ```typescript
 * const evaluator = createTestReflectionEvaluator({ passAfter: 2 });
 * const reflective = withReflection(runner, { evaluate: evaluator });
 * ```
 */
declare function createTestReflectionEvaluator(options?: {
    /** Pass after this many evaluations (1 = pass on first try). Default: 1 */
    passAfter?: number;
    /** Feedback to provide on failure */
    feedback?: string;
    /** Score to assign (0-1) */
    score?: number;
}): ReflectionEvaluator;
/**
 * Assert that a scratchpad contains expected values.
 *
 * @example
 * ```typescript
 * assertScratchpadState(orchestrator.scratchpad!, {
 *   "plan.status": "complete",
 *   "research.results": expect.any(Array),
 * });
 * ```
 */
declare function assertScratchpadState(scratchpad: Scratchpad, expected: Record<string, unknown>): void;
/**
 * Assert that derived values match expected values.
 *
 * @example
 * ```typescript
 * assertDerivedValues(orchestrator, {
 *   totalRuns: 3,
 *   allComplete: true,
 * });
 * ```
 */
declare function assertDerivedValues(orchestrator: MultiAgentOrchestrator, expected: Record<string, unknown>): void;

export { type ApprovalSimulator, type ApprovalSimulatorOptions, type BreakpointCapable, type BreakpointSimulatorOptions, type ConstraintSnapshot, type GuardrailTestInput, type GuardrailTestResult, type MockAgentConfig, type MockAgentRunner, type MockAgentRunnerOptions, type RecordedCall, type TestMultiAgentOrchestrator, type TestMultiAgentOrchestratorOptions, type TestOrchestrator, type TestOrchestratorOptions, assertAgentHealth, assertBreakpointHit, assertCheckpoint, assertDagExecution, assertDerivedValues, assertMultiAgentState, assertMultiplexedStream, assertOrchestratorState, assertRerouted, assertScratchpadState, assertTimelineEvents, collectMultiplexedStream, createApprovalSimulator, createBreakpointSimulator, createConstraintRecorder, createFailingRunner, createMockAgentRunner, createMockSchema, createMockTask, createTestCheckpointStore, createTestDag, createTestMultiAgentOrchestrator, createTestOrchestrator, createTestReflectionEvaluator, createTestTimeline, createTimeController, testGuardrail, testGuardrailBatch };
