async execute(
  ensemble: string,
  inputs: Record<string, any>,
  options?: ExecutionOptions
): Promise<ExecutionResult>

async executeAgent(
  agent: string,
  inputs: Record<string, any>,
  options?: ExecutionOptions
): Promise<AgentResult>

async executeWithStreaming(
  ensemble: string,
  inputs: Record<string, any>
): AsyncIterator<StreamChunk>

for await (const chunk of conductor.executeWithStreaming('chat', { message: 'Hello' })) {
  if (chunk.type === 'token') {
    process.stdout.write(chunk.token);
  }
}

async getState(ensembleId: string): Promise<State>

interface State {
  [key: string]: any;
}

async setState(
  ensembleId: string,
  state: Record<string, any>
): Promise<void>

watchState(
  ensembleId: string,
  callback: (state: State) => void
): () => void

const unsubscribe = conductor.watchState('exec-123', (state) => {
  console.log('State updated:', state);
});

// Later
unsubscribe();

async listEnsembles(filters?: EnsembleFilters): Promise<Ensemble[]>

interface EnsembleFilters {
  tags?: string[];
  search?: string;
}

async getEnsemble(name: string): Promise<Ensemble>

interface Ensemble {
  name: string;
  description?: string;
  inputs: InputSchema;
  outputs: OutputSchema;
  agents: string[];
  version?: string;
  tags?: string[];
}

async listAgents(filters?: AgentFilters): Promise<Agent[]>

async getAgent(name: string): Promise<Agent>

async getComponent(
  name: string,
  version?: string
): Promise<Component>

// Latest version
const prompt = await conductor.getComponent('user-prompt');

// Specific version
const prompt = await conductor.getComponent('user-prompt', 'v1.2.0');

async listComponents(filters?: ComponentFilters): Promise<Component[]>

interface Component {
  name: string;
  type: 'prompt' | 'template' | 'schema' | 'config';
  version: string;
  content: any;
  metadata?: Record<string, any>;
}

async getComponentVersions(name: string): Promise<string[]>

async listExecutions(filters?: ExecutionFilters): Promise<Execution[]>

interface ExecutionFilters {
  ensemble?: string;
  status?: ExecutionStatus;
  startTime?: Date;
  endTime?: Date;
  limit?: number;
}

async getExecution(executionId: string): Promise<ExecutionDetail>

interface ExecutionDetail {
  id: string;
  ensemble: string;
  status: ExecutionStatus;
  input: Record<string, any>;
  output?: Record<string, any>;
  error?: ExecutionError;
  trace: ExecutionTrace;
  duration: number;
  timestamp: number;
}

async getExecutionLogs(executionId: string): Promise<LogEntry[]>

async cancelExecution(executionId: string): Promise<void>

const result = conductor.execute('long-task', input);

// Cancel after 5 seconds
setTimeout(() => {
  conductor.cancelExecution(result.id);
}, 5000);

async execute(inputs: Record<string, any>): Promise<AgentResult>

async executeWithTrace(inputs: Record<string, any>): Promise<AgentResultWithTrace>

interface AgentResultWithTrace {
  output: any;
  duration: number;
  operations: DetailedOperationTrace[];
}

interface DetailedOperationTrace {
  name: string;
  operation: string;
  input: any;
  output: any;
  duration: number;
  cached: boolean;
  retries: number;
  error?: OperationError;
}

import { loadYAML } from '@ensemble/conductor/sdk';

const ensemble = await loadYAML('./ensembles/my-workflow.yaml');

import { validateEnsemble } from '@ensemble/conductor/sdk';

const errors = await validateEnsemble(ensembleConfig);
if (errors.length > 0) {
  console.error('Validation errors:', errors);
}

import { parseExpression } from '@ensemble/conductor/sdk';

const expr = parseExpression('${input.name}');
console.log('Variables:', expr.variables); // ['input.name']

import type {
  // Core types
  ConductorOptions,
  ExecutionResult,
  ExecutionOptions,
  ExecutionError,
  
  // Agent types
  AgentResult,
  AgentConfig,
  OperationConfig,
  
  // State types
  State,
  StateSchema,
  
  // Component types
  Component,
  ComponentType,
  
  // Execution types
  ExecutionStatus,
  ExecutionTrace,
  LogEntry
} from '@ensemble/conductor';

import { retry } from '@ensemble/conductor/sdk';

const result = await retry(
  () => conductor.execute('flaky-ensemble', input),
  {
    maxAttempts: 3,
    backoff: 'exponential',
    onRetry: (attempt, error) => {
      console.log(`Retry attempt ${attempt}:`, error.message);
    }
  }
);

import { timeout } from '@ensemble/conductor/sdk';

const result = await timeout(
  conductor.execute('slow-ensemble', input),
  5000, // 5 seconds
  'Execution timed out'
);

import { parallel } from '@ensemble/conductor/sdk';

const results = await parallel([
  conductor.execute('ensemble-1', input1),
  conductor.execute('ensemble-2', input2),
  conductor.execute('ensemble-3', input3)
]);