@lov3kaizen/agentsea-crews 1.1.0 → 1.2.0

package/dist/Crew-BnvVjN7A.d.mts

@@ -0,0 +1,1060 @@
+type ProficiencyLevel = 'novice' | 'intermediate' | 'expert' | 'master';
+interface Capability {
+    name: string;
+    description: string;
+    proficiency: ProficiencyLevel;
+    tools?: string[];
+    keywords?: string[];
+}
+interface RoleConfig {
+    name: string;
+    description: string;
+    capabilities: Capability[];
+    systemPrompt: string;
+    goals?: string[];
+    constraints?: string[];
+    backstory?: string;
+    canDelegate?: boolean;
+    canReceiveDelegation?: boolean;
+    maxConcurrentTasks?: number;
+}
+interface CapabilityMatch {
+    matched: Capability[];
+    missing: Capability[];
+    score: number;
+    canExecute: boolean;
+}
+interface RankedAgent {
+    agentName: string;
+    score: number;
+    matchedCapabilities: Capability[];
+    missingCapabilities: Capability[];
+}
+declare const PROFICIENCY_WEIGHTS: Record<ProficiencyLevel, number>;
+
+type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
+type TaskStatus = 'pending' | 'assigned' | 'in_progress' | 'completed' | 'failed' | 'blocked' | 'cancelled';
+interface TaskConfig {
+    id?: string;
+    description: string;
+    expectedOutput: string;
+    priority?: TaskPriority;
+    dependencies?: string[];
+    deadline?: Date;
+    context?: Record<string, unknown>;
+    assignTo?: string;
+    requiredCapabilities?: string[];
+    estimatedTokens?: number;
+    maxRetries?: number;
+    timeoutMs?: number;
+    tags?: string[];
+}
+interface TaskResult {
+    output: string;
+    structuredOutput?: unknown;
+    quality?: number;
+    completedAt: Date;
+    iterations: number;
+    tokensUsed: number;
+    latencyMs?: number;
+    cost?: number;
+    completedBy: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TaskMetadata {
+    createdAt: Date;
+    updatedAt: Date;
+    attempts: number;
+    assignedAt?: Date;
+    startedAt?: Date;
+    estimatedDuration?: number;
+    actualDuration?: number;
+    statusHistory?: Array<{
+        status: TaskStatus;
+        timestamp: Date;
+        reason?: string;
+    }>;
+}
+interface TaskState {
+    config: TaskConfig;
+    status: TaskStatus;
+    assignedAgent?: string;
+    result?: TaskResult;
+    metadata: TaskMetadata;
+}
+declare const PRIORITY_WEIGHTS: Record<TaskPriority, number>;
+
+type StepMode = 'sequential' | 'parallel' | 'conditional' | 'loop';
+type StepHandler = (context: WorkflowContext) => Promise<StepResult>;
+type ConditionFn = (context: WorkflowContext) => boolean | Promise<boolean>;
+interface WorkflowStepConfig {
+    name: string;
+    type?: 'step' | 'conditional' | 'loop' | 'parallel' | 'task' | 'crew' | 'checkpoint';
+    description?: string;
+    agent?: string;
+    agentName?: string;
+    task?: TaskConfig;
+    taskConfig?: TaskConfig;
+    handler?: StepHandler;
+    dependsOn?: string[];
+    timeoutMs?: number;
+    retry?: RetryConfig;
+    checkpoint?: boolean;
+}
+interface RetryConfig {
+    maxAttempts: number;
+    delayMs?: number;
+    backoffMultiplier?: number;
+    maxDelayMs?: number;
+    retryOn?: string[];
+}
+interface ParallelStepConfig {
+    name?: string;
+    type?: string;
+    steps: WorkflowStepConfig[];
+    waitFor: 'all' | 'any' | 'first-success';
+    maxConcurrent?: number;
+}
+interface ConditionalStepConfig {
+    name?: string;
+    type?: string;
+    condition: ConditionFn;
+    ifTrue?: WorkflowStepConfig;
+    ifFalse?: WorkflowStepConfig;
+    thenSteps?: WorkflowStepConfig[];
+    elseSteps?: WorkflowStepConfig[];
+}
+interface LoopStepConfig {
+    name?: string;
+    type?: string;
+    condition: ConditionFn;
+    body?: WorkflowStepConfig;
+    bodySteps?: WorkflowStepConfig[];
+    maxIterations?: number;
+}
+interface StepResult {
+    stepName: string;
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    durationMs: number;
+    tokensUsed?: number;
+    executedBy?: string;
+    metadata?: Record<string, unknown>;
+}
+interface WorkflowContext {
+    workflowId?: string;
+    currentStep?: string;
+    stepName?: string;
+    results?: Map<string, StepResult>;
+    stepResults?: Map<string, StepResult>;
+    state?: Map<string, unknown>;
+    variables: Record<string, unknown> | Map<string, unknown>;
+    input?: string;
+    crew?: unknown;
+    signal?: AbortSignal;
+    setVariable?: (key: string, value: unknown) => void;
+    getVariable?: (key: string) => unknown;
+    emit?: (event: Record<string, unknown>) => void;
+    isAborted?: () => boolean;
+}
+interface WorkflowDefinition {
+    id?: string;
+    name: string;
+    description?: string;
+    version?: string;
+    steps: WorkflowStep[] | WorkflowStepConfig[];
+    entryPoint?: string;
+    timeoutMs?: number;
+    checkpointing?: CheckpointConfig;
+    handlers?: Map<string, StepHandler>;
+}
+interface WorkflowStep {
+    id: string;
+    name: string;
+    type: StepMode;
+    config: WorkflowStepConfig | ParallelStepConfig | ConditionalStepConfig | LoopStepConfig;
+    dependencies: string[];
+    nextSteps: string[];
+}
+interface CheckpointConfig {
+    enabled: boolean;
+    afterEveryStep?: boolean;
+    atSteps?: string[];
+    storage?: 'memory' | 'file' | 'redis';
+    ttlMs?: number;
+    interval?: number | 'after-step';
+}
+interface WorkflowCheckpoint {
+    id: string;
+    workflowId: string;
+    workflowName?: string;
+    timestamp: Date;
+    lastCompletedStep?: string;
+    stepIndex?: number;
+    stepResults: Map<string, StepResult> | Record<string, StepResult>;
+    state?: Map<string, unknown>;
+    variables: Record<string, unknown>;
+    input?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DAGNode {
+    id: string;
+    name?: string;
+    step?: WorkflowStep;
+    stepConfig?: WorkflowStepConfig;
+    dependencies?: string[];
+    incomingEdges?: string[];
+    outgoingEdges?: string[];
+    state?: 'pending' | 'ready' | 'running' | 'completed' | 'failed' | 'skipped';
+    result?: StepResult;
+}
+interface DAG {
+    id?: string;
+    nodes: DAGNode[];
+    entryNode?: string;
+    exitNodes?: string[];
+    isValid?: boolean;
+    edges?: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+interface DAGResult {
+    success: boolean;
+    stepResults?: Map<string, StepResult>;
+    results?: Map<string, StepResult>;
+    events?: DAGEvent[];
+    output?: unknown;
+    executionOrder?: string[];
+    totalDurationMs?: number;
+    executionTimeMs?: number;
+    errors?: Array<{
+        stepId: string;
+        error: string;
+    }>;
+    failedNodes?: string[];
+}
+interface DAGEvent {
+    type: 'step:started' | 'step:completed' | 'step:failed' | 'step:skipped' | 'dag:completed' | 'dag:start' | 'dag:aborted' | 'dag:error' | 'dag:complete' | 'node:start' | 'node:complete' | 'node:error' | 'node:retry' | 'node:skipped';
+    dagId?: string;
+    stepId?: string;
+    nodeId?: string;
+    nodeName?: string;
+    timestamp: Date;
+    result?: StepResult;
+    error?: string;
+    attempt?: number;
+    reason?: string;
+    success?: boolean;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+type CrewEvent = CrewStartedEvent | CrewCompletedEvent | CrewErrorEvent | CrewPausedEvent | CrewResumedEvent | CrewAbortedEvent | TaskQueuedEvent | TaskAssignedEvent | TaskStartedEvent | TaskProgressEvent | TaskCompletedEvent | TaskFailedEvent | TaskRetriedEvent | AgentThinkingEvent | AgentToolUseEvent | AgentToolResultEvent | AgentResponseEvent | AgentErrorEvent | DelegationDecisionEvent | DelegationFailedEvent | DelegationRejectedEvent | CollaborationMessageEvent | HelpRequestedEvent | HelpProvidedEvent | HelpRequestEvent | HelpResponseEvent | KnowledgeSharedEvent | KnowledgeContributedEvent | ConflictDetectedEvent | ConflictResolvedEvent | ConflictEscalatedEvent | ConsensusRequestedEvent | ConsensusReachedEvent | ConsensusVoteEvent | AuctionStartedEvent | WorkflowStepStartedEvent | WorkflowStepCompletedEvent | WorkflowCheckpointEvent | MetricsUpdateEvent | DebugBreakpointEvent;
+interface BaseEvent {
+    type: string;
+    timestamp: Date;
+    crewName: string;
+}
+interface CrewStartedEvent extends BaseEvent {
+    type: 'crew:started';
+    taskCount: number;
+    agentCount: number;
+    strategy: DelegationStrategyType;
+}
+interface CrewCompletedEvent extends BaseEvent {
+    type: 'crew:completed';
+    success: boolean;
+    results: TaskResult[];
+    metrics: CrewMetrics;
+    finalOutput?: string;
+}
+interface CrewErrorEvent extends BaseEvent {
+    type: 'crew:error';
+    error: string;
+    fatal: boolean;
+    taskId?: string;
+    agentName?: string;
+}
+interface CrewPausedEvent extends BaseEvent {
+    type: 'crew:paused';
+    reason?: string;
+    pendingTasks: number;
+}
+interface CrewResumedEvent extends BaseEvent {
+    type: 'crew:resumed';
+    fromCheckpoint?: string;
+}
+interface CrewAbortedEvent extends BaseEvent {
+    type: 'crew:aborted';
+    reason: string;
+    completedTasks: number;
+    pendingTasks: number;
+}
+interface TaskQueuedEvent extends BaseEvent {
+    type: 'task:queued';
+    taskId: string;
+    description: string;
+    priority: string;
+    dependencies: string[];
+}
+interface TaskAssignedEvent extends BaseEvent {
+    type: 'task:assigned';
+    taskId: string;
+    agentName: string;
+    reason: string;
+    strategy: DelegationStrategyType;
+}
+interface TaskStartedEvent extends BaseEvent {
+    type: 'task:started';
+    taskId: string;
+    agentName: string;
+}
+interface TaskProgressEvent extends BaseEvent {
+    type: 'task:progress';
+    taskId: string;
+    agentName: string;
+    progress: number;
+    message?: string;
+}
+interface TaskCompletedEvent extends BaseEvent {
+    type: 'task:completed';
+    taskId: string;
+    agentName: string;
+    result: TaskResult;
+    durationMs: number;
+}
+interface TaskFailedEvent extends BaseEvent {
+    type: 'task:failed';
+    taskId: string;
+    agentName: string;
+    error: string;
+    willRetry: boolean;
+    attempt: number;
+}
+interface TaskRetriedEvent extends BaseEvent {
+    type: 'task:retried';
+    taskId: string;
+    agentName: string;
+    attempt: number;
+    maxAttempts: number;
+    reason: string;
+}
+interface AgentThinkingEvent extends BaseEvent {
+    type: 'agent:thinking';
+    agentName: string;
+    taskId: string;
+    thought: string;
+    iteration: number;
+}
+interface AgentToolUseEvent extends BaseEvent {
+    type: 'agent:tool_use';
+    agentName: string;
+    taskId: string;
+    toolName: string;
+    toolInput: unknown;
+}
+interface AgentToolResultEvent extends BaseEvent {
+    type: 'agent:tool_result';
+    agentName: string;
+    taskId: string;
+    toolName: string;
+    result: unknown;
+    durationMs: number;
+}
+interface AgentResponseEvent extends BaseEvent {
+    type: 'agent:response';
+    agentName: string;
+    taskId: string;
+    response: string;
+    tokensUsed: number;
+}
+interface AgentErrorEvent extends BaseEvent {
+    type: 'agent:error';
+    agentName: string;
+    taskId?: string;
+    error: string;
+    recoverable: boolean;
+}
+interface DelegationDecisionEvent extends BaseEvent {
+    type: 'delegation:decision';
+    taskId: string;
+    fromAgent?: string;
+    toAgent: string;
+    strategy: DelegationStrategyType;
+    reason: string;
+    confidence: number;
+    alternatives?: string[];
+}
+interface DelegationFailedEvent extends BaseEvent {
+    type: 'delegation:failed';
+    taskId: string;
+    reason: string;
+    attemptedAgents: string[];
+}
+interface DelegationRejectedEvent extends BaseEvent {
+    type: 'delegation:rejected';
+    taskId: string;
+    agentName: string;
+    reason: string;
+}
+interface CollaborationMessageEvent extends BaseEvent {
+    type: 'collaboration:message';
+    fromAgent: string;
+    toAgent: string;
+    message: string;
+    messageType: 'request' | 'response' | 'info' | 'question';
+    taskId?: string;
+}
+interface HelpRequestedEvent extends BaseEvent {
+    type: 'collaboration:help_requested';
+    fromAgent: string;
+    taskId: string;
+    request: string;
+    targetAgents?: string[];
+}
+interface HelpProvidedEvent extends BaseEvent {
+    type: 'collaboration:help_provided';
+    fromAgent: string;
+    toAgent: string;
+    taskId: string;
+    response: string;
+    helpful: boolean;
+}
+interface KnowledgeSharedEvent extends BaseEvent {
+    type: 'collaboration:knowledge_shared';
+    fromAgent: string;
+    topic: string;
+    content: string;
+    confidence: number;
+}
+interface ConflictDetectedEvent extends BaseEvent {
+    type: 'conflict:detected';
+    conflictId: string;
+    conflictType: 'disagreement' | 'contradiction' | 'resource' | 'priority';
+    agents: string[];
+    taskId?: string;
+    description: string;
+    severity: 'low' | 'medium' | 'high';
+}
+interface ConflictResolvedEvent extends BaseEvent {
+    type: 'conflict:resolved';
+    conflictId: string;
+    resolution: string;
+    resolvedBy: 'voting' | 'manager' | 'merge' | 'escalation';
+    accepted: boolean;
+}
+interface ConflictEscalatedEvent extends BaseEvent {
+    type: 'conflict:escalated';
+    conflictId: string;
+    reason: string;
+    escalatedTo: string;
+}
+interface HelpRequestEvent extends BaseEvent {
+    type: 'collaboration:help_request';
+    from: string;
+    taskId: string;
+    request: string;
+    targetAgents?: string[];
+}
+interface HelpResponseEvent extends BaseEvent {
+    type: 'collaboration:help_response';
+    from: string;
+    to: string;
+    taskId: string;
+    response: string;
+    helpful: boolean;
+}
+interface KnowledgeContributedEvent extends BaseEvent {
+    type: 'collaboration:knowledge_contributed';
+    contributor: string;
+    topic: string;
+    content: string;
+}
+interface ConsensusRequestedEvent extends BaseEvent {
+    type: 'consensus:requested';
+    taskId: string;
+    topic: string;
+    options: string[];
+    requiredVotes: number;
+}
+interface ConsensusReachedEvent extends BaseEvent {
+    type: 'consensus:reached';
+    taskId: string;
+    decision: string;
+    votes: Record<string, string>;
+    unanimous: boolean;
+}
+interface ConsensusVoteEvent extends BaseEvent {
+    type: 'consensus:vote';
+    taskId: string;
+    voter: string;
+    vote: string;
+    reason?: string;
+}
+interface AuctionStartedEvent extends BaseEvent {
+    type: 'auction:started';
+    taskId: string;
+    description: string;
+    participants: string[];
+}
+interface WorkflowStepStartedEvent extends BaseEvent {
+    type: 'workflow:step_started';
+    workflowId: string;
+    stepName: string;
+    agentName?: string;
+}
+interface WorkflowStepCompletedEvent extends BaseEvent {
+    type: 'workflow:step_completed';
+    workflowId: string;
+    stepName: string;
+    result: StepResult;
+    nextSteps: string[];
+}
+interface WorkflowCheckpointEvent extends BaseEvent {
+    type: 'workflow:checkpoint';
+    workflowId: string;
+    checkpointId: string;
+    stepName: string;
+    canResume: boolean;
+}
+interface MetricsUpdateEvent extends BaseEvent {
+    type: 'metrics:update';
+    metrics: Partial<CrewMetrics>;
+    interval: 'tick' | 'task' | 'minute';
+}
+interface DebugBreakpointEvent extends BaseEvent {
+    type: 'debug:breakpoint';
+    breakpointType: 'step' | 'task' | 'agent' | 'error';
+    agentName?: string;
+    taskId?: string;
+    stepName?: string;
+    state: Record<string, unknown>;
+}
+type CrewEventHandler<T extends CrewEvent = CrewEvent> = (event: T) => void | Promise<void>;
+interface EventSubscription {
+    unsubscribe: () => void;
+}
+interface EventFilterOptions {
+    types?: string[];
+    agents?: string[];
+    tasks?: string[];
+    minSeverity?: 'low' | 'medium' | 'high';
+}
+
+type DelegationStrategyType = 'round-robin' | 'best-match' | 'auction' | 'hierarchical' | 'consensus';
+type CrewStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed' | 'aborted';
+interface CrewStatusDetails {
+    state: CrewStatus;
+    currentIteration: number;
+    maxIterations: number;
+    startTime?: Date;
+    endTime?: Date;
+    tasksPending: number;
+    tasksInProgress: number;
+    tasksCompleted: number;
+    tasksFailed: number;
+    agentsBusy: number;
+    agentsAvailable: number;
+}
+interface CrewAgentConfig {
+    name: string;
+    role: RoleConfig;
+    model: string;
+    provider: string;
+    tools?: string[];
+    temperature?: number;
+    maxTokens?: number;
+    maxIterations?: number;
+    parallelCapable?: boolean;
+}
+interface ManagerConfig {
+    role: RoleConfig;
+    model: string;
+    provider: string;
+    allowDelegation?: boolean;
+    reviewsOutput?: boolean;
+    maxDelegations?: number;
+}
+interface CrewMemoryConfig {
+    shared?: boolean;
+    type: 'buffer' | 'summary' | 'vector' | 'hybrid';
+    maxMessages?: number;
+    persistent?: boolean;
+    enableKnowledgeBase?: boolean;
+}
+interface CrewConfig {
+    name: string;
+    description?: string;
+    agents: CrewAgentConfig[];
+    manager?: ManagerConfig;
+    delegationStrategy: DelegationStrategyType;
+    memory?: CrewMemoryConfig;
+    verbose?: boolean;
+    maxIterations?: number;
+    shareKnowledge?: boolean;
+    enableCollaboration?: boolean;
+    enableConflictResolution?: boolean;
+    timeoutMs?: number;
+    maxConcurrentTasks?: number;
+    globalContext?: Record<string, unknown>;
+    mock?: boolean;
+    execute?: (input: string, systemPrompt: string) => Promise<{
+        output: string;
+        tokensUsed: number;
+        latencyMs: number;
+        iterations: number;
+        toolCalls?: Array<{
+            tool: string;
+            input: unknown;
+            result: unknown;
+        }>;
+    }>;
+    provider?: CoreLLMProvider;
+}
+interface CoreLLMProvider {
+    generateResponse(messages: Array<{
+        role: string;
+        content: string;
+    }>, config: {
+        model: string;
+        systemPrompt?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<{
+        content: string;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>;
+}
+interface CrewResult {
+    success: boolean;
+    taskResults: TaskResult[];
+    finalOutput?: string;
+    metrics: CrewMetrics;
+    errors?: Array<{
+        taskId?: string;
+        agentName?: string;
+        error: string;
+        timestamp: Date;
+    }>;
+    timeline?: TimelineEntry[];
+    events?: CrewEvent[];
+}
+interface CrewMetrics {
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    totalTokens: number;
+    totalExecutionTimeMs: number;
+    averageTaskTimeMs: number;
+    totalIterations: number;
+    totalCost?: number;
+    agentMetrics: Record<string, AgentMetrics>;
+    delegationStats?: {
+        totalDelegations: number;
+        byStrategy: Record<DelegationStrategyType, number>;
+        averageConfidence: number;
+    };
+    startedAt?: Date;
+    completedAt?: Date;
+}
+interface AgentMetrics {
+    tasksAssigned: number;
+    tasksCompleted: number;
+    tasksFailed: number;
+    tokensUsed: number;
+    averageLatencyMs: number;
+}
+interface DelegationStats {
+    totalDelegations: number;
+    successfulDelegations: number;
+    reDelegations: number;
+    avgDecisionTimeMs: number;
+    byStrategy: Record<DelegationStrategyType, number>;
+}
+interface TimelineEntry {
+    timestamp: Date;
+    type?: string;
+    event?: string;
+    agentName?: string;
+    entityId?: string;
+    taskId?: string;
+    description?: string;
+    data?: Record<string, unknown>;
+}
+interface CrewCheckpoint {
+    id: string;
+    crewId?: string;
+    crewName?: string;
+    timestamp: Date;
+    status?: CrewStatus;
+    state?: CrewStatus;
+    context?: Record<string, unknown>;
+    taskStates?: TaskState[];
+    taskQueue?: TaskConfig[];
+    results?: Record<string, TaskResult>;
+    timeline?: TimelineEntry[];
+    iteration?: number;
+    agentStates?: Record<string, unknown>;
+    sharedMemory?: Record<string, unknown>;
+    contextState?: Record<string, unknown>;
+    metrics?: Partial<CrewMetrics>;
+}
+interface CrewProgress {
+    percentComplete?: number;
+    percentage?: number;
+    phase?: 'initializing' | 'delegating' | 'executing' | 'reviewing' | 'completing';
+    tasksCompleted: number;
+    totalTasks: number;
+    activeAgents?: string[];
+    currentTask?: string;
+    estimatedRemainingMs?: number;
+}
+
+declare class Role {
+    readonly name: string;
+    readonly description: string;
+    readonly capabilities: Capability[];
+    readonly systemPrompt: string;
+    readonly goals: string[];
+    readonly constraints: string[];
+    readonly backstory: string;
+    readonly canDelegate: boolean;
+    readonly canReceiveDelegation: boolean;
+    readonly maxConcurrentTasks: number;
+    private capabilityMap;
+    constructor(config: RoleConfig);
+    generateSystemPrompt(): string;
+    hasCapability(name: string): boolean;
+    getCapability(name: string): Capability | undefined;
+    getProficiency(name: string): ProficiencyLevel | undefined;
+    getProficiencyScore(name: string): number;
+    getRequiredTools(): string[];
+    getKeywords(): string[];
+    matchCapabilities(required: Capability[]): CapabilityMatch;
+    calculateRelevanceScore(taskDescription: string): number;
+    toJSON(): RoleConfig;
+    static fromJSON(json: RoleConfig): Role;
+    static simple(name: string, description: string, systemPrompt: string, capabilities?: string[]): Role;
+}
+declare function createRole(config: RoleConfig): Role;
+
+declare class Task {
+    readonly id: string;
+    readonly description: string;
+    readonly expectedOutput: string;
+    readonly priority: TaskPriority;
+    readonly dependencies: string[];
+    readonly deadline?: Date;
+    readonly context: Record<string, unknown>;
+    readonly assignTo?: string;
+    readonly requiredCapabilities: string[];
+    readonly estimatedTokens?: number;
+    readonly maxRetries: number;
+    readonly timeoutMs?: number;
+    readonly tags: string[];
+    private _status;
+    private _assignedAgent?;
+    private _result?;
+    private _metadata;
+    constructor(config: TaskConfig);
+    get status(): TaskStatus;
+    get assignedAgent(): string | undefined;
+    get result(): TaskResult | undefined;
+    get metadata(): TaskMetadata;
+    get isCompleted(): boolean;
+    get isFailed(): boolean;
+    get isPending(): boolean;
+    get isBlocked(): boolean;
+    get isInProgress(): boolean;
+    get isAssigned(): boolean;
+    get attempts(): number;
+    assign(agentName: string): void;
+    start(): void;
+    complete(result: Omit<TaskResult, 'completedAt' | 'completedBy'>): void;
+    fail(error: string): void;
+    block(reason?: string): void;
+    unblock(): void;
+    cancel(reason?: string): void;
+    reset(): void;
+    canStart(completedTaskIds?: Set<string>): boolean;
+    dependenciesSatisfied(completedTaskIds: Set<string>): boolean;
+    canRetry(): boolean;
+    isPastDeadline(): boolean;
+    getTimeRemaining(): number | null;
+    getPriorityWeight(): number;
+    compareTo(other: Task): number;
+    private updateStatus;
+    getState(): TaskState;
+    toConfig(): TaskConfig;
+    toJSON(): TaskState;
+    static fromState(state: TaskState): Task;
+}
+declare function createTask(config: TaskConfig): Task;
+
+interface ExecutionContextConfig {
+    crewName: string;
+    crewId?: string;
+    globalContext?: Record<string, unknown>;
+    bufferEvents?: boolean;
+    maxBufferSize?: number;
+}
+interface ContextCheckpoint {
+    id: string;
+    timestamp: Date;
+    crewId: string;
+    crewName: string;
+    state: Map<string, unknown>;
+    completedTasks: Map<string, TaskResult>;
+    agentStates: Map<string, unknown>;
+    variables: Record<string, unknown>;
+}
+declare class ExecutionContext {
+    readonly crewId: string;
+    readonly crewName: string;
+    private state;
+    private completedTasks;
+    private agentStates;
+    private variables;
+    private eventEmitter;
+    private eventBuffer;
+    private bufferEvents;
+    private maxBufferSize;
+    private abortController;
+    private status;
+    private startTime?;
+    private endTime?;
+    constructor(config: ExecutionContextConfig);
+    set(key: string, value: unknown): void;
+    get<T>(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    keys(): string[];
+    entries(): Array<[string, unknown]>;
+    clearState(): void;
+    setVariable(name: string, value: unknown): void;
+    getVariable<T>(name: string): T | undefined;
+    getVariables(): Record<string, unknown>;
+    markTaskCompleted(taskId: string, result: TaskResult): void;
+    isTaskCompleted(taskId: string): boolean;
+    getTaskResult(taskId: string): TaskResult | undefined;
+    getCompletedTasks(): Map<string, TaskResult>;
+    getCompletedTaskIds(): Set<string>;
+    getCompletedTaskCount(): number;
+    setAgentState(agentName: string, state: unknown): void;
+    getAgentState<T>(agentName: string): T | undefined;
+    getAgentStates(): Map<string, unknown>;
+    emit(event: {
+        type: string;
+    } & Record<string, unknown>): void;
+    on<T extends CrewEvent>(type: T['type'] | '*', handler: CrewEventHandler<T>): EventSubscription;
+    once<T extends CrewEvent>(type: T['type'], handler: CrewEventHandler<T>): EventSubscription;
+    off(type: string): void;
+    getEventBuffer(): CrewEvent[];
+    clearEventBuffer(): void;
+    get signal(): AbortSignal;
+    get isAborted(): boolean;
+    abort(reason?: string): void;
+    getStatus(): CrewStatus;
+    setStatus(status: CrewStatus): void;
+    getDuration(): number | undefined;
+    createCheckpoint(): ContextCheckpoint;
+    restoreCheckpoint(checkpoint: ContextCheckpoint): void;
+    exportState(): Record<string, unknown>;
+    importState(data: Record<string, unknown>): void;
+    reset(): void;
+}
+declare function createExecutionContext(config: ExecutionContextConfig): ExecutionContext;
+
+interface CapableAgent {
+    name: string;
+    capabilities: Capability[];
+    isBusy?: boolean;
+    executeTask?: (task: TaskConfig) => Promise<TaskResult>;
+    getStats?: () => {
+        name: string;
+        role?: string;
+        tasksCompleted: number;
+        tasksFailed: number;
+        totalTokensUsed: number;
+        successRate?: number;
+        isBusy?: boolean;
+        currentTask?: string;
+    };
+}
+declare class AgentCapabilities {
+    static match(required: Capability[], available: Capability[]): CapabilityMatch;
+    static score(capability: Capability, task: TaskConfig): number;
+    static calculateAgentScore(agent: CapableAgent, task: TaskConfig): number;
+    static rank(agents: CapableAgent[], task: TaskConfig): RankedAgent[];
+    static findBestMatch(agents: CapableAgent[], task: TaskConfig): RankedAgent | undefined;
+    static findCapableAgents(agents: CapableAgent[], task: TaskConfig): RankedAgent[];
+    static canAnyHandle(agents: CapableAgent[], task: TaskConfig): boolean;
+    static calculateOverlap(agent1: CapableAgent, agent2: CapableAgent): number;
+    static getAllCapabilities(agents: CapableAgent[]): Capability[];
+    static getUniqueCapabilities(agents: CapableAgent[]): Map<string, Capability[]>;
+}
+
+interface TaskBid {
+    agentName: string;
+    taskId: string;
+    confidence: number;
+    estimatedTime?: number;
+    estimatedCost?: number;
+    reasoning: string;
+    capabilities: string[];
+}
+interface HelpRequest {
+    requestId: string;
+    fromAgent: string;
+    taskId: string;
+    request: string;
+    context?: Record<string, unknown>;
+}
+interface HelpResponse {
+    requestId: string;
+    fromAgent: string;
+    response: string;
+    helpful: boolean;
+}
+interface AgentExecutionResult {
+    output: string;
+    tokensUsed: number;
+    latencyMs: number;
+    iterations: number;
+    toolCalls?: Array<{
+        tool: string;
+        input: unknown;
+        result: unknown;
+    }>;
+}
+interface CrewAgentOptions {
+    config: CrewAgentConfig;
+    execute?: (input: string, systemPrompt: string) => Promise<AgentExecutionResult>;
+    mock?: boolean;
+    provider?: CoreLLMProvider;
+}
+declare class CrewAgent implements CapableAgent {
+    readonly id: string;
+    readonly name: string;
+    readonly role: Role;
+    readonly capabilities: Capability[];
+    readonly model: string;
+    readonly provider: string;
+    readonly tools: string[];
+    readonly temperature: number;
+    readonly maxTokens?: number;
+    readonly maxIterations: number;
+    readonly parallelCapable: boolean;
+    private executeFunc?;
+    private currentTaskId?;
+    private tasksCompleted;
+    private tasksFailed;
+    private totalTokensUsed;
+    constructor(options: CrewAgentOptions);
+    execute(input: string): Promise<AgentExecutionResult>;
+    executeTask(task: TaskConfig): Promise<TaskResult>;
+    private formatTaskInput;
+    hasCapability(name: string): boolean;
+    getProficiencyScore(name: string): number;
+    matchesCapabilities(required: Capability[]): CapabilityMatch;
+    calculateTaskScore(task: TaskConfig): number;
+    bidOnTask(task: TaskConfig): Promise<TaskBid>;
+    private estimateTaskCost;
+    private hasRequiredCapabilities;
+    private estimateTaskTime;
+    private generateBidReasoning;
+    createHelpRequest(taskId: string, request: string): HelpRequest;
+    respondToHelpRequest(request: HelpRequest): Promise<HelpResponse>;
+    provideHelp(task: TaskConfig, question: string, _context: ExecutionContext): Promise<{
+        helpful: boolean;
+        response: string;
+        suggestions?: string[];
+    }>;
+    private extractSuggestions;
+    get isBusy(): boolean;
+    getCurrentTask(): string | undefined;
+    getStats(): CrewAgentStats;
+    toConfig(): CrewAgentConfig;
+    static fromConfig(config: CrewAgentConfig): CrewAgent;
+}
+interface CrewAgentStats {
+    name: string;
+    role: string;
+    tasksCompleted: number;
+    tasksFailed: number;
+    totalTokensUsed: number;
+    successRate: number;
+    isBusy: boolean;
+    currentTask?: string;
+}
+declare function createCrewAgent(options: CrewAgentOptions): CrewAgent;
+
+interface CrewExecutionOptions {
+    input?: string;
+    context?: Record<string, unknown>;
+    delegationStrategy?: DelegationStrategyType;
+    timeoutMs?: number;
+    maxConcurrentTasks?: number;
+    verbose?: boolean;
+}
+declare class Crew {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    private readonly config;
+    private readonly agents;
+    private readonly taskQueue;
+    private readonly delegation;
+    private readonly collaboration;
+    private readonly conflictResolver;
+    private context;
+    private state;
+    private startTime?;
+    private endTime?;
+    private currentIteration;
+    private readonly maxIterations;
+    private readonly timeline;
+    private readonly results;
+    constructor(config: CrewConfig);
+    private initializeAgents;
+    addAgent(agent: CrewAgent): void;
+    removeAgent(name: string): void;
+    getAgent(name: string): CrewAgent | undefined;
+    getAgents(): CrewAgent[];
+    addTask(taskConfig: TaskConfig): Task;
+    addTasks(tasks: TaskConfig[]): Task[];
+    getTask(taskId: string): Task | undefined;
+    getTasks(): Task[];
+    kickoff(options?: CrewExecutionOptions): Promise<CrewResult>;
+    kickoffStream(options?: CrewExecutionOptions): AsyncGenerator<CrewEvent>;
+    private processReadyTasksConcurrently;
+    private delegateTask;
+    private executeTask;
+    private buildFinalOutput;
+    pause(): void;
+    resume(): void;
+    abort(): void;
+    getStatus(): CrewStatusDetails;
+    getMetrics(): CrewMetrics;
+    getProgress(): CrewProgress;
+    getTimeline(): TimelineEntry[];
+    createCheckpoint(): CrewCheckpoint;
+    restoreCheckpoint(checkpoint: CrewCheckpoint): void;
+    private addTimelineEntry;
+    private sleep;
+    private createEvent;
+    reset(): void;
+    getConfig(): CrewConfig;
+}
+declare function createCrew(config: CrewConfig): Crew;
+
+export { type ConsensusVoteEvent as $, type AgentExecutionResult as A, type AgentMetrics as B, type CrewStatusDetails as C, type DelegationStrategyType as D, ExecutionContext as E, type AgentResponseEvent as F, type AgentThinkingEvent as G, type AgentToolResultEvent as H, type AgentToolUseEvent as I, type AuctionStartedEvent as J, type BaseEvent as K, type LoopStepConfig as L, type Capability as M, type CapabilityMatch as N, type CheckpointConfig as O, type ParallelStepConfig as P, type CollaborationMessageEvent as Q, type RoleConfig as R, type StepResult as S, type TimelineEntry as T, type ConflictDetectedEvent as U, type ValidationResult as V, type WorkflowContext as W, type ConflictEscalatedEvent as X, type ConflictResolvedEvent as Y, type ConsensusReachedEvent as Z, type ConsensusRequestedEvent as _, Crew as a, type ContextCheckpoint as a0, type CrewAbortedEvent as a1, type CrewAgentOptions as a2, type CrewAgentStats as a3, type CrewCheckpoint as a4, type CrewCompletedEvent as a5, type CrewErrorEvent as a6, type CrewEventHandler as a7, type CrewMemoryConfig as a8, type CrewPausedEvent as a9, type RetryConfig as aA, Role as aB, type StepMode as aC, type TaskAssignedEvent as aD, type TaskCompletedEvent as aE, type TaskFailedEvent as aF, type TaskMetadata as aG, type TaskProgressEvent as aH, type TaskQueuedEvent as aI, type TaskRetriedEvent as aJ, type TaskStartedEvent as aK, type TaskState as aL, type WorkflowCheckpointEvent as aM, type WorkflowStep as aN, type WorkflowStepCompletedEvent as aO, type WorkflowStepStartedEvent as aP, createCrew as aQ, createCrewAgent as aR, createExecutionContext as aS, createRole as aT, createTask as aU, type CrewProgress as aa, type CrewResumedEvent as ab, type CrewStartedEvent as ac, type CrewStatus as ad, type DAGNode as ae, type DebugBreakpointEvent as af, type DelegationDecisionEvent as ag, type DelegationFailedEvent as ah, type DelegationRejectedEvent as ai, type DelegationStats as aj, type EventFilterOptions as ak, type EventSubscription as al, type ExecutionContextConfig as am, type HelpProvidedEvent as an, type HelpRequest as ao, type HelpRequestEvent as ap, type HelpRequestedEvent as aq, type HelpResponse as ar, type HelpResponseEvent as as, type KnowledgeContributedEvent as at, type KnowledgeSharedEvent as au, type ManagerConfig as av, type MetricsUpdateEvent as aw, PRIORITY_WEIGHTS as ax, PROFICIENCY_WEIGHTS as ay, type ProficiencyLevel as az, type CrewEvent as b, type CrewMetrics as c, type TaskConfig as d, type CrewConfig as e, type CrewExecutionOptions as f, type CrewResult as g, Task as h, type TaskStatus as i, type TaskPriority as j, type CrewAgentConfig as k, type CoreLLMProvider as l, type CapableAgent as m, type RankedAgent as n, CrewAgent as o, type TaskBid as p, type WorkflowStepConfig as q, type ConditionalStepConfig as r, type WorkflowDefinition as s, type DAG as t, type DAGResult as u, type DAGEvent as v, type TaskResult as w, type WorkflowCheckpoint as x, AgentCapabilities as y, type AgentErrorEvent as z };