@lov3kaizen/agentsea-crews 1.0.1 → 1.1.1

package/dist/index.d.mts

@@ -0,0 +1,975 @@
+import { h as Task, i as TaskStatus, j as TaskPriority, k as CrewAgentConfig, l as CoreLLMProvider, A as AgentExecutionResult, m as CapableAgent, d as TaskConfig, n as RankedAgent, D as DelegationStrategyType, o as CrewAgent, E as ExecutionContext, p as TaskBid, W as WorkflowContext, S as StepResult, q as WorkflowStepConfig, r as ConditionalStepConfig, P as ParallelStepConfig, L as LoopStepConfig, s as WorkflowDefinition, t as DAG, u as DAGResult, v as DAGEvent, V as ValidationResult, w as TaskResult, x as WorkflowCheckpoint } from './Crew-BnvVjN7A.mjs';
+export { y as AgentCapabilities, z as AgentErrorEvent, B as AgentMetrics, F as AgentResponseEvent, G as AgentThinkingEvent, H as AgentToolResultEvent, I as AgentToolUseEvent, J as AuctionStartedEvent, K as BaseEvent, M as Capability, N as CapabilityMatch, O as CheckpointConfig, Q as CollaborationMessageEvent, U as ConflictDetectedEvent, X as ConflictEscalatedEvent, Y as ConflictResolvedEvent, Z as ConsensusReachedEvent, _ as ConsensusRequestedEvent, $ as ConsensusVoteEvent, a0 as ContextCheckpoint, a as Crew, a1 as CrewAbortedEvent, a2 as CrewAgentOptions, a3 as CrewAgentStats, a4 as CrewCheckpoint, a5 as CrewCompletedEvent, e as CrewConfig, a6 as CrewErrorEvent, b as CrewEvent, a7 as CrewEventHandler, f as CrewExecutionOptions, a8 as CrewMemoryConfig, c as CrewMetrics, a9 as CrewPausedEvent, aa as CrewProgress, g as CrewResult, ab as CrewResumedEvent, ac as CrewStartedEvent, ad as CrewStatus, C as CrewStatusDetails, ae as DAGNode, af as DebugBreakpointEvent, ag as DelegationDecisionEvent, ah as DelegationFailedEvent, ai as DelegationRejectedEvent, aj as DelegationStats, ak as EventFilterOptions, al as EventSubscription, am as ExecutionContextConfig, an as HelpProvidedEvent, ao as HelpRequest, ap as HelpRequestEvent, aq as HelpRequestedEvent, ar as HelpResponse, as as HelpResponseEvent, at as KnowledgeContributedEvent, au as KnowledgeSharedEvent, av as ManagerConfig, aw as MetricsUpdateEvent, ax as PRIORITY_WEIGHTS, ay as PROFICIENCY_WEIGHTS, az as ProficiencyLevel, aA as RetryConfig, aB as Role, R as RoleConfig, aC as StepMode, aD as TaskAssignedEvent, aE as TaskCompletedEvent, aF as TaskFailedEvent, aG as TaskMetadata, aH as TaskProgressEvent, aI as TaskQueuedEvent, aJ as TaskRetriedEvent, aK as TaskStartedEvent, aL as TaskState, T as TimelineEntry, aM as WorkflowCheckpointEvent, aN as WorkflowStep, aO as WorkflowStepCompletedEvent, aP as WorkflowStepStartedEvent, aQ as createCrew, aR as createCrewAgent, aS as createExecutionContext, aT as createRole, aU as createTask } from './Crew-BnvVjN7A.mjs';
+import { EventEmitter } from 'eventemitter3';
+export { A as AgentInspection, a as AgentStatus, B as Breakpoint, b as BreakpointType, C as CrewDashboard, c as DashboardConfig, d as DashboardSnapshot, e as DashboardUpdate, f as DebugContext, D as DebugMode, g as DebugModeConfig, S as StepResult, h as createDashboard, i as createDebugMode } from './DebugMode-CbYgA7Yw.mjs';
+export { CodeReviewCrewOptions, CodeReviewTasks, CustomerSupportCrewOptions, CustomerSupportTasks, ResearchCrewOptions, ResearchTasks, WritingCrewOptions, WritingTasks, createCodeReviewCrew, createCodeReviewCrewConfig, createCustomerSupportCrew, createCustomerSupportCrewConfig, createResearchCrew, createResearchCrewConfig, createWritingCrew, createWritingCrewConfig } from './templates/index.mjs';
+
+interface TaskQueueConfig {
+    maxSize?: number;
+    autoSort?: boolean;
+    defaultPriority?: 'critical' | 'high' | 'medium' | 'low';
+}
+declare class TaskQueue {
+    private tasks;
+    private taskMap;
+    private readonly maxSize;
+    private readonly autoSort;
+    private dirty;
+    constructor(config?: TaskQueueConfig);
+    enqueue(task: Task): void;
+    enqueueMany(tasks: Task[]): void;
+    dequeue(): Task | undefined;
+    peek(): Task | undefined;
+    get(id: string): Task | undefined;
+    remove(id: string): Task | undefined;
+    has(id: string): boolean;
+    clear(): void;
+    getByStatus(status: TaskStatus): Task[];
+    getByPriority(priority: TaskPriority): Task[];
+    getReadyTasks(completedTaskIds?: Set<string>): Task[];
+    getByAgent(agentName: string): Task[];
+    getByTag(tag: string): Task[];
+    getPending(): Task[];
+    getBlocked(): Task[];
+    getInProgress(): Task[];
+    getFailed(): Task[];
+    getRetryable(): Task[];
+    getOverdue(): Task[];
+    getNextReady(n: number, completedTaskIds?: Set<string>): Task[];
+    get size(): number;
+    isEmpty(): boolean;
+    isFull(): boolean;
+    getAll(): Task[];
+    getAllIds(): string[];
+    getStats(): TaskQueueStats;
+    sort(): void;
+    updateBlockedTasks(completedTaskIds: Set<string>): number;
+    blockDependentTasks(failedTaskId: string): number;
+    reprioritize(taskId: string, _newPriority: TaskPriority): boolean;
+    [Symbol.iterator](): Iterator<Task>;
+    forEach(callback: (task: Task, index: number) => void): void;
+    filter(predicate: (task: Task) => boolean): Task[];
+    find(predicate: (task: Task) => boolean): Task | undefined;
+}
+interface TaskQueueStats {
+    total: number;
+    byStatus: Record<TaskStatus, number>;
+    byPriority: Record<TaskPriority, number>;
+    overdue: number;
+    retryable: number;
+}
+declare function createTaskQueue(config?: TaskQueueConfig): TaskQueue;
+
+declare function createCoreExecutor(config: CrewAgentConfig, options?: {
+    provider?: CoreLLMProvider;
+}): (input: string, systemPrompt: string) => Promise<AgentExecutionResult>;
+
+type AgentStatus = 'available' | 'busy' | 'unavailable' | 'error';
+interface RegisteredAgent<T extends CapableAgent = CapableAgent> {
+    agent: T;
+    status: AgentStatus;
+    currentTask?: string;
+    registeredAt: Date;
+    lastActiveAt?: Date;
+    tasksCompleted: number;
+    tasksFailed: number;
+    metadata?: Record<string, unknown>;
+}
+interface AgentRegistryConfig {
+    allowDuplicates?: boolean;
+    trackStats?: boolean;
+}
+declare class AgentRegistry<T extends CapableAgent = CapableAgent> {
+    private agents;
+    private readonly allowDuplicates;
+    private readonly trackStats;
+    constructor(config?: AgentRegistryConfig);
+    register(agent: T, metadata?: Record<string, unknown>): void;
+    registerMany(agents: T[]): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    get(name: string): T | undefined;
+    getEntry(name: string): RegisteredAgent<T> | undefined;
+    getAll(): T[];
+    getAllEntries(): RegisteredAgent<T>[];
+    getNames(): string[];
+    get size(): number;
+    getStatus(name: string): AgentStatus | undefined;
+    setStatus(name: string, status: AgentStatus): void;
+    markBusy(name: string, taskId: string): void;
+    markAvailable(name: string): void;
+    recordTaskCompletion(name: string, success: boolean): void;
+    findByCapability(capabilityName: string): T[];
+    findByRole(roleName: string): T[];
+    findBestMatch(task: TaskConfig): T | undefined;
+    rankForTask(task: TaskConfig): RankedAgent[];
+    findCapableAgents(task: TaskConfig): T[];
+    getAvailable(): T[];
+    getBusy(): T[];
+    getByStatus(status: AgentStatus): T[];
+    getAvailableCount(): number;
+    hasAvailable(): boolean;
+    getStats(): RegistryStats;
+    getAgentStats(name: string): AgentStats | undefined;
+    [Symbol.iterator](): Iterator<T>;
+    forEach(callback: (agent: T, name: string) => void): void;
+    clear(): void;
+    resetAllStatuses(): void;
+}
+interface RegistryStats {
+    total: number;
+    available: number;
+    busy: number;
+    unavailable: number;
+    error: number;
+    totalTasksCompleted: number;
+    totalTasksFailed: number;
+}
+interface AgentStats {
+    name: string;
+    status: AgentStatus;
+    currentTask?: string;
+    tasksCompleted: number;
+    tasksFailed: number;
+    successRate: number;
+    registeredAt: Date;
+    lastActiveAt?: Date;
+}
+declare function createAgentRegistry<T extends CapableAgent = CapableAgent>(config?: AgentRegistryConfig): AgentRegistry<T>;
+
+interface DelegationResult {
+    selectedAgent: string;
+    reason: string;
+    confidence: number;
+    alternativeAgents?: string[];
+    decisionTimeMs?: number;
+    metadata?: Record<string, unknown>;
+}
+interface DelegationFailure {
+    reason: string;
+    consideredAgents: string[];
+    suggestions?: string[];
+}
+interface DelegationStrategy {
+    readonly name: DelegationStrategyType;
+    selectAgent(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<DelegationResult>;
+    assignTasks?(tasks: TaskConfig[], agents: CrewAgent[], context: ExecutionContext): Promise<Map<string, string>>;
+    reset?(): void;
+}
+declare abstract class BaseDelegationStrategy implements DelegationStrategy {
+    abstract readonly name: DelegationStrategyType;
+    abstract selectAgent(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<DelegationResult>;
+    assignTasks(tasks: TaskConfig[], agents: CrewAgent[], context: ExecutionContext): Promise<Map<string, string>>;
+    protected filterAvailable(agents: CrewAgent[]): CrewAgent[];
+    protected createFailure(reason: string, agents: CrewAgent[]): never;
+    reset(): void;
+}
+declare class DelegationError extends Error {
+    readonly failure: DelegationFailure;
+    constructor(failureOrReason: DelegationFailure | string, agents?: CrewAgent[], lastError?: string);
+}
+
+interface RoundRobinConfig {
+    skipBusy?: boolean;
+    wrapAround?: boolean;
+}
+declare class RoundRobinStrategy extends BaseDelegationStrategy {
+    readonly name: "round-robin";
+    private currentIndex;
+    private readonly skipBusy;
+    private readonly wrapAround;
+    constructor(config?: RoundRobinConfig);
+    selectAgent(task: TaskConfig, agents: CrewAgent[], _context: ExecutionContext): Promise<DelegationResult>;
+    assignTasks(tasks: TaskConfig[], agents: CrewAgent[], _context: ExecutionContext): Promise<Map<string, string>>;
+    reset(): void;
+    getCurrentPosition(): number;
+    setPosition(position: number): void;
+}
+declare function createRoundRobinStrategy(config?: RoundRobinConfig): RoundRobinStrategy;
+
+interface BestMatchConfig {
+    minimumScore?: number;
+    useKeywordMatching?: boolean;
+    capabilityWeight?: number;
+    preferAvailable?: boolean;
+}
+declare class BestMatchStrategy extends BaseDelegationStrategy {
+    readonly name: "best-match";
+    private readonly minimumScore;
+    private readonly useKeywordMatching;
+    private readonly capabilityWeight;
+    private readonly preferAvailable;
+    constructor(config?: BestMatchConfig);
+    selectAgent(task: TaskConfig, agents: CrewAgent[], _context: ExecutionContext): Promise<DelegationResult>;
+    private rankAgents;
+    private buildReason;
+    findCapableAgents(task: TaskConfig, agents: CrewAgent[]): CrewAgent[];
+}
+declare function createBestMatchStrategy(config?: BestMatchConfig): BestMatchStrategy;
+
+interface AuctionConfig {
+    biddingTimeMs?: number;
+    minimumBid?: number;
+    selectionCriteria?: 'confidence' | 'fastest' | 'cheapest';
+    allowRebidding?: boolean;
+    bidTimeoutMs?: number;
+}
+declare class AuctionStrategy extends BaseDelegationStrategy {
+    readonly name: "auction";
+    private readonly biddingTimeMs;
+    private readonly minimumBid;
+    private readonly selectionCriteria;
+    private readonly allowRebidding;
+    private readonly bidTimeoutMs;
+    constructor(config?: AuctionConfig);
+    selectAgent(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<DelegationResult>;
+    private collectBids;
+    private getBidWithTimeout;
+    private selectWinner;
+    private buildReason;
+    runMultiRoundAuction(task: TaskConfig, agents: CrewAgent[], rounds?: number): Promise<TaskBid[]>;
+}
+declare function createAuctionStrategy(config?: AuctionConfig): AuctionStrategy;
+
+interface AgentHierarchy {
+    managers: string[];
+    workers: Map<string, string[]>;
+    authorityLevels?: Map<string, number>;
+}
+interface HierarchicalConfig {
+    hierarchy?: AgentHierarchy | string[];
+    managersCanExecute?: boolean;
+    escalateToManager?: boolean;
+    useCapabilityMatching?: boolean;
+}
+declare class HierarchicalStrategy extends BaseDelegationStrategy {
+    readonly name: "hierarchical";
+    private hierarchy;
+    private readonly managersCanExecute;
+    private readonly escalateToManager;
+    private readonly useCapabilityMatching;
+    private rolePriority;
+    constructor(config?: HierarchicalConfig);
+    setHierarchy(hierarchy: AgentHierarchy): void;
+    addManager(managerName: string, workers?: string[]): void;
+    addWorker(managerName: string, workerName: string): void;
+    selectAgent(task: TaskConfig, agents: CrewAgent[], _context: ExecutionContext): Promise<DelegationResult>;
+    private autoDetectHierarchy;
+    private findManagerForTask;
+    private selectWorker;
+    private fallbackSelection;
+    private selectByRolePriority;
+    reset(): void;
+    getHierarchy(): AgentHierarchy;
+}
+declare function createHierarchicalStrategy(config?: HierarchicalConfig): HierarchicalStrategy;
+
+interface Vote {
+    voter: string;
+    candidate: string;
+    weight: number;
+    reasoning?: string;
+}
+interface ConsensusConfig {
+    requiredAgreement?: number;
+    maxRounds?: number;
+    tieBreaker?: 'random' | 'first' | 'manager' | 'highest-capability';
+    voteTimeoutMs?: number;
+    weightedVoting?: boolean;
+    minimumVotes?: number;
+}
+interface VotingRound {
+    round: number;
+    votes: Vote[];
+    tally: Map<string, number>;
+    winner?: string;
+    consensusReached: boolean;
+    agreementRatio: number;
+}
+declare class ConsensusStrategy extends BaseDelegationStrategy {
+    readonly name: "consensus";
+    private readonly requiredAgreement;
+    private readonly maxRounds;
+    private readonly tieBreaker;
+    private readonly voteTimeoutMs;
+    private readonly weightedVoting;
+    private readonly minimumVotes;
+    constructor(config?: ConsensusConfig);
+    selectAgent(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<DelegationResult>;
+    private runVotingRound;
+    private collectVotes;
+    private getVote;
+    private tallyVotes;
+    private breakTie;
+    runWithDeliberation(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<{
+        result: DelegationResult;
+        deliberation: VotingRound[];
+        consensus: boolean;
+    }>;
+}
+declare function createConsensusStrategy(config?: ConsensusConfig): ConsensusStrategy;
+
+declare function createStrategy(type: DelegationStrategyType, config?: Record<string, unknown>): DelegationStrategy;
+declare const STRATEGY_TYPES: DelegationStrategyType[];
+
+interface DelegationCoordinatorConfig {
+    defaultStrategy?: DelegationStrategyType;
+    strategyConfigs?: Partial<Record<DelegationStrategyType, Record<string, unknown>>>;
+    enableFallback?: boolean;
+    fallbackOrder?: DelegationStrategyType[];
+    maxAttempts?: number;
+    trackHistory?: boolean;
+}
+interface DelegationHistoryEntry {
+    taskId: string;
+    strategy: DelegationStrategyType;
+    result: DelegationResult;
+    timestamp: Date;
+    attempt: number;
+}
+declare class DelegationCoordinator {
+    private readonly strategies;
+    private readonly defaultStrategy;
+    private readonly enableFallback;
+    private readonly fallbackOrder;
+    private readonly maxAttempts;
+    private readonly trackHistory;
+    private readonly history;
+    constructor(config?: DelegationCoordinatorConfig);
+    registerStrategy(type: DelegationStrategyType, strategy: DelegationStrategy): void;
+    getStrategy(type: DelegationStrategyType): DelegationStrategy | undefined;
+    delegate(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext, strategyType?: DelegationStrategyType): Promise<DelegationResult>;
+    delegateBatch(tasks: TaskConfig[], agents: CrewAgent[], context: ExecutionContext, strategyType?: DelegationStrategyType): Promise<Map<string, DelegationResult>>;
+    findBestAgent(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext): Promise<CrewAgent | undefined>;
+    getRecommendations(task: TaskConfig, agents: CrewAgent[], context: ExecutionContext, limit?: number): Promise<Array<{
+        agent: CrewAgent;
+        score: number;
+        reason: string;
+    }>>;
+    getHistory(taskId?: string): DelegationHistoryEntry[];
+    getStatistics(): {
+        totalDelegations: number;
+        byStrategy: Record<string, number>;
+        averageConfidence: number;
+        averageAttempts: number;
+    };
+    clearHistory(): void;
+    reset(): void;
+    private buildStrategyOrder;
+}
+declare function createDelegationCoordinator(config?: DelegationCoordinatorConfig): DelegationCoordinator;
+
+type CollaborationMessageType = 'request' | 'response' | 'broadcast' | 'acknowledgment' | 'knowledge' | 'question' | 'answer';
+interface CollaborationMessage {
+    id: string;
+    type: CollaborationMessageType;
+    from: string;
+    to: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    replyTo?: string;
+    timestamp: Date;
+}
+interface HelpResponse {
+    requestId: string;
+    responder: string;
+    helpful: boolean;
+    response: string;
+    suggestions?: string[];
+    timestamp: Date;
+}
+interface Knowledge {
+    id: string;
+    contributor: string;
+    type: 'fact' | 'insight' | 'procedure' | 'example' | 'warning';
+    content: string;
+    tags: string[];
+    confidence: number;
+    timestamp: Date;
+}
+interface CollaborationChannel {
+    name: string;
+    participants: string[];
+    messages: CollaborationMessage[];
+    created: Date;
+}
+interface CollaborationConfig {
+    persistMessages?: boolean;
+    maxMessagesPerChannel?: number;
+    helpRequestTimeoutMs?: number;
+    autoExtractKnowledge?: boolean;
+}
+declare class CollaborationManager {
+    private readonly agents;
+    private readonly channels;
+    private readonly pendingHelpRequests;
+    private readonly knowledge;
+    private readonly config;
+    private messageCounter;
+    constructor(config?: CollaborationConfig);
+    registerAgent(agent: CrewAgent): void;
+    unregisterAgent(agentName: string): void;
+    createChannel(name: string, participants: string[]): CollaborationChannel;
+    sendMessage(from: string, to: string, content: string, context: ExecutionContext, options?: {
+        type?: CollaborationMessageType;
+        replyTo?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<CollaborationMessage>;
+    broadcast(from: string, content: string, context: ExecutionContext): Promise<CollaborationMessage>;
+    requestHelp(requester: string, task: TaskConfig, question: string, context: ExecutionContext, priority?: 'low' | 'normal' | 'high' | 'urgent'): Promise<HelpResponse[]>;
+    private getHelpFromAgent;
+    shareKnowledge(contributor: string, type: Knowledge['type'], content: string, tags: string[], context: ExecutionContext, confidence?: number): Knowledge;
+    searchKnowledge(query: string, limit?: number): Knowledge[];
+    getKnowledgeByType(type: Knowledge['type']): Knowledge[];
+    getKnowledgeByContributor(contributor: string): Knowledge[];
+    getConversation(agent1: string, agent2: string): CollaborationMessage[];
+    getAgentChannels(agentName: string): CollaborationChannel[];
+    clear(): void;
+    getStatistics(): {
+        totalMessages: number;
+        totalChannels: number;
+        totalKnowledge: number;
+        messagesByAgent: Record<string, number>;
+        knowledgeByType: Record<string, number>;
+    };
+}
+declare function createCollaborationManager(config?: CollaborationConfig): CollaborationManager;
+
+type ConflictType = 'disagreement' | 'resource' | 'priority' | 'dependency' | 'output' | 'assertion';
+interface AgentResponse {
+    agentName: string;
+    content: string;
+    confidence: number;
+    reasoning?: string;
+    metadata?: Record<string, unknown>;
+}
+interface Conflict {
+    id: string;
+    type: ConflictType;
+    description: string;
+    participants: string[];
+    responses: AgentResponse[];
+    task?: TaskConfig;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    detected: Date;
+}
+type ResolutionStrategy = 'voting' | 'authority' | 'consensus' | 'merge' | 'human' | 'newest' | 'highest-confidence';
+interface Resolution {
+    conflictId: string;
+    strategy: ResolutionStrategy;
+    winner?: AgentResponse;
+    merged?: string;
+    explanation: string;
+    successful: boolean;
+    escalated: boolean;
+    resolved: Date;
+}
+interface ConflictResolverConfig {
+    defaultStrategy?: ResolutionStrategy;
+    autoResolveThreshold?: number;
+    autoDetect?: boolean;
+    escalateOnRepeated?: number;
+    trackHistory?: boolean;
+}
+declare class ConflictResolver {
+    private readonly config;
+    private readonly history;
+    private readonly conflictCounts;
+    private conflictCounter;
+    constructor(config?: ConflictResolverConfig);
+    detectConflict(responses: AgentResponse[], task: TaskConfig, context: ExecutionContext): Conflict | null;
+    resolve(conflict: Conflict, context: ExecutionContext, strategy?: ResolutionStrategy): Promise<Resolution>;
+    private createConflict;
+    private detectDisagreement;
+    private detectContradiction;
+    private areContradictory;
+    private resolveByConfidence;
+    private resolveByNewest;
+    private normalizeContent;
+    private resolveByVoting;
+    private resolveByAuthority;
+    private resolveByConsensus;
+    private resolveByMerge;
+    private escalate;
+    getHistory(conflictId?: string): Resolution[];
+    getStatistics(): {
+        totalConflicts: number;
+        byStrategy: Record<string, number>;
+        successRate: number;
+        escalationRate: number;
+    };
+    clear(): void;
+}
+declare function createConflictResolver(config?: ConflictResolverConfig): ConflictResolver;
+
+type StepHandler = (context: WorkflowContext) => Promise<StepResult>;
+type ConditionFn = (context: WorkflowContext) => boolean | Promise<boolean>;
+interface StepDefinition {
+    type: 'step' | 'parallel' | 'conditional' | 'loop' | 'checkpoint';
+    config: WorkflowStepConfig | ParallelStepConfig | ConditionalStepConfig | LoopStepConfig;
+    handler?: StepHandler;
+    children?: StepDefinition[];
+}
+declare class BranchBuilder {
+    private readonly parent;
+    private readonly condition;
+    private thenSteps;
+    private elseSteps;
+    constructor(parent: WorkflowBuilder, condition: ConditionFn);
+    then(builder: (b: WorkflowBuilder) => WorkflowBuilder): BranchBuilder;
+    otherwise(builder: (b: WorkflowBuilder) => WorkflowBuilder): BranchBuilder;
+    endBranch(): WorkflowBuilder;
+}
+declare class LoopBuilder {
+    private readonly parent;
+    private readonly condition;
+    private bodySteps;
+    private maxIter;
+    constructor(parent: WorkflowBuilder, condition: ConditionFn);
+    do(builder: (b: WorkflowBuilder) => WorkflowBuilder): LoopBuilder;
+    maxIterations(max: number): LoopBuilder;
+    endLoop(): WorkflowBuilder;
+}
+declare class WorkflowBuilder {
+    private readonly name;
+    private description?;
+    private readonly steps;
+    private readonly stepHandlers;
+    private checkpointEnabled;
+    private checkpointInterval;
+    constructor(name: string);
+    describe(description: string): WorkflowBuilder;
+    addStep(name: string, handler: StepHandler, options?: Partial<WorkflowStepConfig>): WorkflowBuilder;
+    parallel(...steps: Array<{
+        name: string;
+        handler: StepHandler;
+    }>): WorkflowBuilder;
+    sequential(...steps: Array<{
+        name: string;
+        handler: StepHandler;
+    }>): WorkflowBuilder;
+    when(condition: ConditionFn): BranchBuilder;
+    while(condition: ConditionFn): LoopBuilder;
+    checkpoint(name: string): WorkflowBuilder;
+    enableCheckpoints(interval?: number | 'after-step'): WorkflowBuilder;
+    task(name: string, description: string, options?: {
+        agent?: string;
+        requiredCapabilities?: string[];
+        timeout?: number;
+    }): WorkflowBuilder;
+    crew(name: string, description: string, options?: {
+        tasks?: Array<{
+            description: string;
+            expectedOutput: string;
+        }>;
+        timeout?: number;
+    }): WorkflowBuilder;
+    addConditional(config: ConditionalStepConfig, thenSteps: StepDefinition[], elseSteps: StepDefinition[]): void;
+    addLoop(config: LoopStepConfig, bodySteps: StepDefinition[]): void;
+    getSteps(): StepDefinition[];
+    build(): WorkflowDefinition;
+    getHandler(stepName: string): StepHandler | undefined;
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+declare function workflow(name: string): WorkflowBuilder;
+
+interface DAGExecutorConfig {
+    maxParallel?: number;
+    defaultTimeout?: number;
+    retryOnFailure?: boolean;
+    maxRetries?: number;
+    enableCaching?: boolean;
+}
+interface NodeState {
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    result?: StepResult;
+    error?: string;
+    startTime?: Date;
+    endTime?: Date;
+    retries: number;
+}
+declare class DAGExecutor {
+    private readonly dag;
+    private readonly _handlers;
+    private readonly config;
+    private readonly nodeStates;
+    private readonly cache;
+    private aborted;
+    constructor(dag: DAG, handlers: Map<string, StepHandler>, config?: DAGExecutorConfig);
+    execute(context: ExecutionContext): Promise<DAGResult>;
+    executeStream(context: ExecutionContext): AsyncGenerator<DAGEvent>;
+    private executeNode;
+    private buildWorkflowContext;
+    private createTimeout;
+    private getReadyNodes;
+    private getDependentNodes;
+    private updateNodeState;
+    private isComplete;
+    private isSuccessful;
+    private getPendingCount;
+    abort(): void;
+    validate(): ValidationResult;
+    private detectCycle;
+    getState(): Map<string, NodeState>;
+    getStatistics(): {
+        totalNodes: number;
+        completed: number;
+        failed: number;
+        skipped: number;
+        pending: number;
+        running: number;
+    };
+}
+declare function createDAGFromSteps(steps: WorkflowStepConfig[], _handlers: Map<string, StepHandler>): DAG;
+declare function createDAGExecutor(dag: DAG, handlers: Map<string, StepHandler>, config?: DAGExecutorConfig): DAGExecutor;
+
+interface ParallelExecutionOptions {
+    maxConcurrency?: number;
+    taskTimeout?: number;
+    failFast?: boolean;
+    continueOnError?: boolean;
+}
+interface ParallelTaskResult {
+    taskId: string;
+    status: 'success' | 'failed' | 'timeout';
+    result?: TaskResult;
+    error?: string;
+    executionTimeMs: number;
+}
+interface BatchResult {
+    results: ParallelTaskResult[];
+    totalTimeMs: number;
+    successCount: number;
+    failureCount: number;
+    allSuccessful: boolean;
+}
+declare class ParallelExecutor {
+    private readonly options;
+    constructor(options?: ParallelExecutionOptions);
+    executeBatch(tasks: TaskConfig[], executor: (task: TaskConfig) => Promise<TaskResult>, _context?: ExecutionContext): Promise<BatchResult>;
+    executeWithAgents(tasks: TaskConfig[], agents: CrewAgent[], context: ExecutionContext): Promise<BatchResult>;
+    map<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>): Promise<Array<{
+        item: T;
+        result?: R;
+        error?: string;
+    }>>;
+    executeBatches<T, R>(items: T[], batchSize: number, processor: (batch: T[]) => Promise<R[]>): Promise<R[]>;
+    private createTimeout;
+}
+declare function createParallelExecutor(options?: ParallelExecutionOptions): ParallelExecutor;
+
+interface CheckpointStorage {
+    save(checkpoint: WorkflowCheckpoint): Promise<string>;
+    load(checkpointId: string): Promise<WorkflowCheckpoint | null>;
+    list(workflowId: string): Promise<string[]>;
+    delete(checkpointId: string): Promise<void>;
+    deleteAll(workflowId: string): Promise<void>;
+}
+declare class InMemoryCheckpointStorage implements CheckpointStorage {
+    private readonly checkpoints;
+    save(checkpoint: WorkflowCheckpoint): Promise<string>;
+    load(checkpointId: string): Promise<WorkflowCheckpoint | null>;
+    list(workflowId: string): Promise<string[]>;
+    delete(checkpointId: string): Promise<void>;
+    deleteAll(workflowId: string): Promise<void>;
+    clear(): void;
+}
+interface CheckpointManagerConfig {
+    storage?: CheckpointStorage;
+    autoCheckpointInterval?: number | 'after-step';
+    maxCheckpoints?: number;
+    compress?: boolean;
+}
+declare class CheckpointManager {
+    private readonly storage;
+    private readonly config;
+    private autoCheckpointTimer?;
+    private stepCounter;
+    private currentWorkflowId?;
+    constructor(config?: CheckpointManagerConfig);
+    save(workflowId: string, state: WorkflowState): Promise<WorkflowCheckpoint>;
+    load(checkpointId: string): Promise<WorkflowCheckpoint | null>;
+    loadLatest(workflowId: string): Promise<WorkflowCheckpoint | null>;
+    delete(checkpointId: string): Promise<void>;
+    deleteAll(workflowId: string): Promise<void>;
+    list(workflowId: string): Promise<WorkflowCheckpoint[]>;
+    enableAutoCheckpoint(workflowId: string, getState: () => WorkflowState): void;
+    disableAutoCheckpoint(): void;
+    onStepComplete(workflowId: string, state: WorkflowState): Promise<void>;
+    restore(checkpointId: string): Promise<WorkflowState | null>;
+    private cleanupOldCheckpoints;
+    export(workflowId: string): Promise<string>;
+    import(data: string): Promise<number>;
+    getStatistics(workflowId: string): Promise<CheckpointStatistics>;
+}
+interface WorkflowState {
+    currentStepIndex: number;
+    stepResults: Map<string, StepResult>;
+    variables: Map<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface CheckpointStatistics {
+    checkpointCount: number;
+    estimatedSizeBytes: number;
+    oldestCheckpoint: Date | null;
+    newestCheckpoint: Date | null;
+}
+declare function createCheckpointManager(config?: CheckpointManagerConfig): CheckpointManager;
+
+interface MemoryChangeEvent {
+    type: 'set' | 'delete' | 'clear';
+    key?: string;
+    value?: unknown;
+    previousValue?: unknown;
+    agent?: string;
+    timestamp: Date;
+}
+interface MemoryNamespace {
+    name: string;
+    data: Map<string, unknown>;
+    created: Date;
+    lastAccessed: Date;
+}
+interface SharedMemoryConfig {
+    maxEntriesPerNamespace?: number;
+    trackHistory?: boolean;
+    maxHistoryEntries?: number;
+    persist?: boolean;
+}
+declare class SharedMemory extends EventEmitter<{
+    change: (event: MemoryChangeEvent) => void;
+    namespaceCreated: (name: string) => void;
+    namespaceDeleted: (name: string) => void;
+}> {
+    private readonly namespaces;
+    private readonly agentNamespaces;
+    private readonly history;
+    private readonly config;
+    constructor(config?: SharedMemoryConfig);
+    setShared(key: string, value: unknown, agent?: string): void;
+    getShared<T>(key: string): T | undefined;
+    deleteShared(key: string, agent?: string): boolean;
+    hasShared(key: string): boolean;
+    getSharedKeys(): string[];
+    setForAgent(agentName: string, key: string, value: unknown): void;
+    getForAgent<T>(agentName: string, key: string): T | undefined;
+    deleteForAgent(agentName: string, key: string): boolean;
+    getAgentKeys(agentName: string): string[];
+    clearAgent(agentName: string): void;
+    broadcast(key: string, value: unknown, fromAgent?: string): void;
+    createNamespace(name: string): MemoryNamespace;
+    deleteNamespace(name: string): boolean;
+    clearNamespace(name: string, agent?: string): void;
+    getNamespaces(): string[];
+    set(namespace: string, key: string, value: unknown, agent?: string): void;
+    get<T>(namespace: string, key: string): T | undefined;
+    delete(namespace: string, key: string, agent?: string): boolean;
+    has(namespace: string, key: string): boolean;
+    getKeys(namespace: string): string[];
+    private addToHistory;
+    getHistory(filter?: {
+        agent?: string;
+        key?: string;
+        type?: 'set' | 'delete' | 'clear';
+        since?: Date;
+    }): MemoryChangeEvent[];
+    clearHistory(): void;
+    export(): Record<string, Record<string, unknown>>;
+    import(data: Record<string, Record<string, unknown>>): void;
+    clear(): void;
+    getStatistics(): {
+        totalNamespaces: number;
+        totalEntries: number;
+        entriesByNamespace: Record<string, number>;
+        historyEntries: number;
+    };
+}
+declare function createSharedMemory(config?: SharedMemoryConfig): SharedMemory;
+
+type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+interface ConversationMessage {
+    id: string;
+    role: MessageRole;
+    content: string;
+    agentName?: string;
+    timestamp: Date;
+    metadata?: {
+        toolCall?: {
+            name: string;
+            input: unknown;
+            output?: unknown;
+        };
+        tokens?: number;
+        model?: string;
+        taskId?: string;
+    };
+}
+interface MultiAgentMessage extends ConversationMessage {
+    agentName: string;
+    replyTo?: string;
+    threadId?: string;
+}
+interface ConversationThread {
+    id: string;
+    title?: string;
+    participants: string[];
+    messages: MultiAgentMessage[];
+    created: Date;
+    lastActivity: Date;
+}
+interface ConversationHistoryConfig {
+    maxMessagesPerAgent?: number;
+    maxTotalMessages?: number;
+    enableThreads?: boolean;
+    autoSummarize?: boolean;
+}
+declare class ConversationHistory {
+    private readonly agentMessages;
+    private readonly threads;
+    private readonly allMessages;
+    private readonly config;
+    private currentThreadId?;
+    constructor(config?: ConversationHistoryConfig);
+    addMessage(agentName: string, message: Omit<ConversationMessage, 'id' | 'timestamp'>): MultiAgentMessage;
+    addUserMessage(content: string, agentName?: string): MultiAgentMessage;
+    addAssistantMessage(agentName: string, content: string, metadata?: ConversationMessage['metadata']): MultiAgentMessage;
+    addSystemMessage(agentName: string, content: string): MultiAgentMessage;
+    addToolMessage(agentName: string, toolName: string, input: unknown, output: unknown): MultiAgentMessage;
+    getAgentHistory(agentName: string, options?: {
+        limit?: number;
+        since?: Date;
+        role?: MessageRole;
+    }): ConversationMessage[];
+    getFullHistory(options?: {
+        limit?: number;
+        since?: Date;
+        agents?: string[];
+    }): MultiAgentMessage[];
+    getConversation(agent1: string, agent2: string, limit?: number): MultiAgentMessage[];
+    getRecent(count?: number): MultiAgentMessage[];
+    searchHistory(query: string, options?: {
+        limit?: number;
+        agent?: string;
+        caseSensitive?: boolean;
+    }): MultiAgentMessage[];
+    createThread(title?: string, participants?: string[]): ConversationThread;
+    switchThread(threadId: string): boolean;
+    getCurrentThread(): ConversationThread | undefined;
+    getThread(threadId: string): ConversationThread | undefined;
+    getThreads(): ConversationThread[];
+    deleteThread(threadId: string): boolean;
+    buildAgentContext(agentName: string, maxMessages?: number): ConversationMessage[];
+    buildLLMContext(agentName: string, options?: {
+        maxMessages?: number;
+        includeSystem?: boolean;
+        includeTools?: boolean;
+    }): Array<{
+        role: string;
+        content: string;
+    }>;
+    summarize(messages: ConversationMessage[]): string;
+    getParticipants(): string[];
+    getMessageCount(agentName?: string): number;
+    clear(): void;
+    clearAgent(agentName: string): void;
+    export(): {
+        messages: MultiAgentMessage[];
+        threads: ConversationThread[];
+    };
+    import(data: {
+        messages: MultiAgentMessage[];
+        threads?: ConversationThread[];
+    }): void;
+    getStatistics(): {
+        totalMessages: number;
+        messagesByAgent: Record<string, number>;
+        messagesByRole: Record<string, number>;
+        totalThreads: number;
+        averageMessagesPerAgent: number;
+    };
+}
+declare function createConversationHistory(config?: ConversationHistoryConfig): ConversationHistory;
+
+type KnowledgeType = 'fact' | 'procedure' | 'concept' | 'example' | 'rule' | 'definition' | 'insight' | 'warning';
+interface KnowledgeItem {
+    id: string;
+    type: KnowledgeType;
+    title: string;
+    content: string;
+    tags: string[];
+    source?: string;
+    contributor?: string;
+    confidence: number;
+    references?: string[];
+    created: Date;
+    updated: Date;
+    accessCount: number;
+    metadata?: Record<string, unknown>;
+}
+interface KnowledgeQueryOptions {
+    type?: KnowledgeType;
+    tags?: string[];
+    contributor?: string;
+    minConfidence?: number;
+    limit?: number;
+    sortBy?: 'relevance' | 'recency' | 'confidence' | 'access';
+}
+interface KnowledgeBaseConfig {
+    maxItems?: number;
+    autoIndex?: boolean;
+    minConfidence?: number;
+    deduplicate?: boolean;
+}
+declare class KnowledgeBase {
+    private readonly items;
+    private readonly tagIndex;
+    private readonly typeIndex;
+    private readonly contributorIndex;
+    private readonly config;
+    constructor(config?: KnowledgeBaseConfig);
+    add(item: Omit<KnowledgeItem, 'id' | 'created' | 'updated' | 'accessCount'>): KnowledgeItem;
+    get(id: string): KnowledgeItem | undefined;
+    update(id: string, updates: Partial<Omit<KnowledgeItem, 'id' | 'created' | 'accessCount'>>): KnowledgeItem;
+    delete(id: string): boolean;
+    search(query: string, options?: KnowledgeQueryOptions): KnowledgeItem[];
+    getByTag(tag: string, limit?: number): KnowledgeItem[];
+    getByType(type: KnowledgeType, limit?: number): KnowledgeItem[];
+    getByContributor(contributor: string, limit?: number): KnowledgeItem[];
+    getRelated(id: string, limit?: number): KnowledgeItem[];
+    contributeKnowledge(agentName: string, type: KnowledgeType, title: string, content: string, tags?: string[], confidence?: number): KnowledgeItem;
+    addFact(title: string, content: string, tags?: string[], source?: string): KnowledgeItem;
+    addProcedure(title: string, steps: string[], tags?: string[]): KnowledgeItem;
+    addInsight(title: string, content: string, contributor: string, tags?: string[]): KnowledgeItem;
+    addWarning(title: string, content: string, tags?: string[]): KnowledgeItem;
+    private indexItem;
+    private unindexItem;
+    private textSearch;
+    private sortResults;
+    private findDuplicate;
+    private evictLeastUsed;
+    getTags(): string[];
+    getTypes(): KnowledgeType[];
+    getContributors(): string[];
+    getAll(): KnowledgeItem[];
+    getCount(): number;
+    clear(): void;
+    export(): KnowledgeItem[];
+    import(items: KnowledgeItem[]): number;
+    getStatistics(): {
+        totalItems: number;
+        itemsByType: Record<string, number>;
+        itemsByContributor: Record<string, number>;
+        totalTags: number;
+        averageConfidence: number;
+        mostUsedTags: Array<{
+            tag: string;
+            count: number;
+        }>;
+    };
+}
+declare function createKnowledgeBase(config?: KnowledgeBaseConfig): KnowledgeBase;
+
+export { AgentExecutionResult, AgentRegistry, type AgentRegistryConfig, type AgentResponse, AuctionStrategy, BaseDelegationStrategy, type BatchResult, BestMatchStrategy, BranchBuilder, CapableAgent, CheckpointManager, type CheckpointManagerConfig, type CheckpointStatistics, type CheckpointStorage, type CollaborationChannel, type CollaborationConfig, CollaborationManager, type CollaborationMessage, type CollaborationMessageType, type ConditionFn, ConditionalStepConfig, type Conflict, ConflictResolver, type ConflictResolverConfig, type ConflictType, ConsensusStrategy, ConversationHistory, type ConversationHistoryConfig, type ConversationMessage, type ConversationThread, CoreLLMProvider, CrewAgent, CrewAgentConfig, DAG, DAGEvent, DAGExecutor, type DAGExecutorConfig, DAGResult, DelegationCoordinator, type DelegationCoordinatorConfig, DelegationError, type DelegationFailure, type DelegationHistoryEntry, type DelegationResult, type DelegationStrategy, DelegationStrategyType, ExecutionContext, HierarchicalStrategy, InMemoryCheckpointStorage, type Knowledge, KnowledgeBase, type KnowledgeBaseConfig, type KnowledgeItem, type KnowledgeQueryOptions, type KnowledgeType, LoopBuilder, LoopStepConfig, type MemoryChangeEvent, type MemoryNamespace, type MessageRole, type MultiAgentMessage, type ParallelExecutionOptions, ParallelExecutor, ParallelStepConfig, type ParallelTaskResult, RankedAgent, type RegisteredAgent, type Resolution, type ResolutionStrategy, RoundRobinStrategy, STRATEGY_TYPES, SharedMemory, type SharedMemoryConfig, type StepHandler, Task, TaskBid, TaskConfig, TaskPriority, TaskQueue, type TaskQueueConfig, type TaskQueueStats, TaskResult, TaskStatus, ValidationResult, WorkflowBuilder, WorkflowCheckpoint, WorkflowContext, WorkflowDefinition, type WorkflowState, WorkflowStepConfig, createAgentRegistry, createAuctionStrategy, createBestMatchStrategy, createCheckpointManager, createCollaborationManager, createConflictResolver, createConsensusStrategy, createConversationHistory, createCoreExecutor, createDAGExecutor, createDAGFromSteps, createDelegationCoordinator, createHierarchicalStrategy, createKnowledgeBase, createParallelExecutor, createRoundRobinStrategy, createSharedMemory, createStrategy, createTaskQueue, workflow };