Skip to main content

​
Overview

Complete TypeScript API reference for Conductor v1.0.0. This section documents all public classes, interfaces, functions, and types available in the @ensemble-edge/conductor package.

​
Installation

npm install @ensemble-edge/conductor

​
Package Exports

Conductor provides three export paths for different use cases:

​
Main Export

import { Conductor, Executor, Parser, StateManager } from '@ensemble-edge/conductor';
Available:
  • Core runtime classes (Executor, Parser, StateManager, GraphExecutor)
  • Member classes (BaseMember, ThinkMember, FunctionMember, DataMember, APIMember)
  • Built-in member registry
  • Type definitions (EnsembleConfig, MemberConfig, ExecutionResult, etc.)

​
SDK Export

import { ConductorClient, createMember } from '@ensemble-edge/conductor/sdk';
Available:
  • ConductorClient - HTTP client for remote Conductor instances
  • createMember - Factory functions for creating members
  • loadComponent - Edgit integration (future)

​
Testing Export

import { TestConductor, registerMatchers } from '@ensemble-edge/conductor/testing';
Available:
  • TestConductor - Testing harness with mocking
  • registerMatchers - Custom Vitest matchers
  • Mock implementations (MockAIProvider, MockDatabase, etc.)

​
TypeScript Support

Conductor is written in TypeScript and provides full type definitions. 
import type {
  EnsembleConfig,
  MemberConfig,
  ExecutionResult,
  MemberResponse,
  ConductorEnv
} from '@ensemble-edge/conductor';

​
Core Architecture

​
Execution Flow

┌──────────────────────────────────────────────────────────┐
│                       Executor                           │
│  • Load ensemble YAML                                    │
│  • Parse configuration                                   │
│  • Initialize state                                      │
│  • Execute workflow                                      │
└──────────────────────────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────┐
│                    GraphExecutor                         │
│  • Resolve dependencies                                  │
│  • Execute members (parallel where possible)             │
│  • Handle conditionals and loops                         │
└──────────────────────────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────┐
│                   BaseMember (Think/Function/Data/API)   │
│  • Execute member logic                                  │
│  • Handle caching                                        │
│  • Return result                                         │
└──────────────────────────────────────────────────────────┘

​
State Management

┌──────────────────────────────────────────────────────────┐
│                    StateManager                          │
│  • Immutable state                                       │
│  • Selective member access                               │
│  • Access tracking                                       │
│  • Pending updates                                       │
└──────────────────────────────────────────────────────────┘

​
API Categories

​
Core Runtime

Executor, Parser, StateManager, GraphExecutor Classes that power workflow execution, YAML parsing, state management, and dependency resolution.

​
Member Types

BaseMember, ThinkMember, FunctionMember, DataMember, APIMember Base classes and implementations for the four member types (Think, Function, Data, API).

​
Built-In Members

Scrape, Validate, RAG, HITL, Fetch, Queries Pre-built members for common tasks (scraping, validation, RAG, human-in-the-loop, HTTP requests, database queries).

​
SDK

ConductorClient, Member Factory, Edgit Client SDK for interacting with Conductor via HTTP and factory functions for creating members programmatically.

​
Testing

TestConductor, Custom Matchers, Mocks Testing utilities including test harness, custom Vitest matchers, and mock implementations.

​
Durable Objects

ExecutionState, HITLState Durable Objects for stateful execution tracking and human-in-the-loop workflows.

​
AI Providers

Provider Registry, Catalog, Routing AI provider system, model catalog, and routing modes (direct, cloudflare-gateway, cloudflare).

​
HTTP API

Execution, Members, Schedules, Webhooks, Health HTTP endpoints for executing ensembles, listing members, managing schedules, handling webhooks, and health checks.

​
Version Information

​
Getting Started

​
Basic Usage

import { Conductor } from '@ensemble-edge/conductor';

// Initialize
const conductor = new Conductor({
  env: {
    AI: env.AI,
    DB: env.DB,
    OPENAI_API_KEY: env.OPENAI_API_KEY
  }
});

// Execute ensemble
const result = await conductor.executeEnsemble('my-workflow', {
  input: 'data'
});

if (result.ok) {
  console.log('Success:', result.value.output);
} else {
  console.error('Error:', result.error.message);
}

​
Testing

import { TestConductor } from '@ensemble-edge/conductor/testing';
import { describe, it, expect } from 'vitest';

describe('my-workflow', () => {
  it('should execute successfully', async () => {
    const conductor = await TestConductor.create();

    const result = await conductor.executeEnsemble('my-workflow', {
      input: 'test data'
    });

    expect(result).toBeSuccessful();
    expect(result.output).toBeDefined();
  });
});

​
Support

Quickstart

Get started with Conductor

Core Classes

Executor, Parser, StateManager

Testing Guide

Test your workflows

Examples

Example workflows