Documentation Index
Fetch the complete documentation index at: https://docs.ensemble.ai/llms.txt
Use this file to discover all available pages before exploring further.
Conductor Methods
Execution
execute()
Execute an ensemble.
async execute(
ensemble: string,
inputs: Record<string, any>,
options?: ExecutionOptions
): Promise<ExecutionResult>
executeAgent()
Execute a single agent.
async executeAgent(
agent: string,
inputs: Record<string, any>,
options?: ExecutionOptions
): Promise<AgentResult>
executeWithStreaming()
Execute with streaming response.
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);
}
}
State Management
getState()
Get ensemble state.
async getState(ensembleId: string): Promise<State>
interface State {
[key: string]: any;
}
setState()
Update ensemble state.
async setState(
ensembleId: string,
state: Record<string, any>
): Promise<void>
watchState()
Watch state changes.
watchState(
ensembleId: string,
callback: (state: State) => void
): () => void
const unsubscribe = conductor.watchState('exec-123', (state) => {
console.log('State updated:', state);
});
// Later
unsubscribe();
Discovery
listEnsembles()
List all ensembles.
async listEnsembles(filters?: EnsembleFilters): Promise<Ensemble[]>
interface EnsembleFilters {
tags?: string[];
search?: string;
}
getEnsemble()
Get ensemble metadata.
async getEnsemble(name: string): Promise<Ensemble>
interface Ensemble {
name: string;
description?: string;
inputs: InputSchema;
outputs: OutputSchema;
agents: string[];
version?: string;
tags?: string[];
}
listAgents()
List all agents.
async listAgents(filters?: AgentFilters): Promise<Agent[]>
getAgent()
Get agent metadata.
async getAgent(name: string): Promise<Agent>
Components (Edgit)
getComponent()
Get a versioned component.
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');
listComponents()
List all components.
async listComponents(filters?: ComponentFilters): Promise<Component[]>
interface Component {
name: string;
type: 'prompt' | 'template' | 'schema' | 'config';
version: string;
content: any;
metadata?: Record<string, any>;
}
getComponentVersions()
Get all versions of a component.
async getComponentVersions(name: string): Promise<string[]>
Execution History
listExecutions()
List past executions.
async listExecutions(filters?: ExecutionFilters): Promise<Execution[]>
interface ExecutionFilters {
ensemble?: string;
status?: ExecutionStatus;
startTime?: Date;
endTime?: Date;
limit?: number;
}
getExecution()
Get execution details.
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;
}
getExecutionLogs()
Get execution logs.
async getExecutionLogs(executionId: string): Promise<LogEntry[]>
Cancellation
cancelExecution()
Cancel a running execution.
async cancelExecution(executionId: string): Promise<void>
const result = conductor.execute('long-task', input);
// Cancel after 5 seconds
setTimeout(() => {
conductor.cancelExecution(result.id);
}, 5000);
Agent Methods
Agent Execution
execute()
Execute agent.
async execute(inputs: Record<string, any>): Promise<AgentResult>
executeWithTrace()
Execute with detailed trace.
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;
}
Helper Methods
loadYAML()
Load and parse YAML file.
import { loadYAML } from '@ensemble/conductor/sdk';
const ensemble = await loadYAML('./ensembles/my-workflow.yaml');
validateEnsemble()
Validate ensemble configuration.
import { validateEnsemble } from '@ensemble/conductor/sdk';
const errors = await validateEnsemble(ensembleConfig);
if (errors.length > 0) {
console.error('Validation errors:', errors);
}
parseExpression()
Parse template expression.
import { parseExpression } from '@ensemble/conductor/sdk';
const expr = parseExpression('${input.name}');
console.log('Variables:', expr.variables); // ['input.name']
Type Exports
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';
Utility Functions
retry()
Retry helper.
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);
}
}
);
timeout()
Timeout helper.
import { timeout } from '@ensemble/conductor/sdk';
const result = await timeout(
conductor.execute('slow-ensemble', input),
5000, // 5 seconds
'Execution timed out'
);
parallel()
Execute multiple ensembles in parallel.
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)
]);
Next Steps
Core Classes
Core class reference
Agent Classes
Agent classes
Testing Utilities
Testing helpers
