@lov3kaizen/agentsea-crews 0.5.1

package/dist/index.mjs

@@ -0,0 +1,2528 @@
+import {
+  CrewDashboard,
+  DebugMode,
+  createDashboard,
+  createDebugMode
+} from "./chunk-4PF73ECN.mjs";
+import {
+  CodeReviewTasks,
+  CustomerSupportTasks,
+  ResearchTasks,
+  WritingTasks,
+  createCodeReviewCrew,
+  createCodeReviewCrewConfig,
+  createCustomerSupportCrew,
+  createCustomerSupportCrewConfig,
+  createResearchCrew,
+  createResearchCrewConfig,
+  createWritingCrew,
+  createWritingCrewConfig
+} from "./chunk-G3PAPYOI.mjs";
+import {
+  AgentCapabilities,
+  AgentRegistry,
+  AuctionStrategy,
+  BaseDelegationStrategy,
+  BestMatchStrategy,
+  CollaborationManager,
+  ConflictResolver,
+  ConsensusStrategy,
+  Crew,
+  CrewAgent,
+  DelegationCoordinator,
+  DelegationError,
+  ExecutionContext,
+  HierarchicalStrategy,
+  Role,
+  RoundRobinStrategy,
+  STRATEGY_TYPES,
+  Task,
+  TaskQueue,
+  createAgentRegistry,
+  createAuctionStrategy,
+  createBestMatchStrategy,
+  createCollaborationManager,
+  createConflictResolver,
+  createConsensusStrategy,
+  createCrew,
+  createCrewAgent,
+  createDelegationCoordinator,
+  createExecutionContext,
+  createHierarchicalStrategy,
+  createRole,
+  createRoundRobinStrategy,
+  createStrategy,
+  createTask,
+  createTaskQueue
+} from "./chunk-QMK3HWFX.mjs";
+
+// src/types/role.types.ts
+var PROFICIENCY_WEIGHTS = {
+  novice: 0.25,
+  intermediate: 0.5,
+  expert: 0.75,
+  master: 1
+};
+
+// src/types/task.types.ts
+var PRIORITY_WEIGHTS = {
+  critical: 100,
+  high: 75,
+  medium: 50,
+  low: 25
+};
+
+// src/workflows/WorkflowBuilder.ts
+import { nanoid } from "nanoid";
+var BranchBuilder = class {
+  parent;
+  condition;
+  thenSteps = [];
+  elseSteps = [];
+  constructor(parent, condition) {
+    this.parent = parent;
+    this.condition = condition;
+  }
+  /**
+   * Add steps for true branch
+   */
+  then(builder) {
+    const subBuilder = new WorkflowBuilder(`then-${nanoid(6)}`);
+    builder(subBuilder);
+    this.thenSteps = subBuilder.getSteps();
+    return this;
+  }
+  /**
+   * Add steps for false branch
+   */
+  otherwise(builder) {
+    const subBuilder = new WorkflowBuilder(`else-${nanoid(6)}`);
+    builder(subBuilder);
+    this.elseSteps = subBuilder.getSteps();
+    return this;
+  }
+  /**
+   * Complete the branch and return to parent builder
+   */
+  endBranch() {
+    const conditionalConfig = {
+      name: `conditional-${nanoid(6)}`,
+      condition: this.condition,
+      thenSteps: this.thenSteps.map((s) => s.config),
+      elseSteps: this.elseSteps.length > 0 ? this.elseSteps.map((s) => s.config) : void 0
+    };
+    this.parent.addConditional(
+      conditionalConfig,
+      this.thenSteps,
+      this.elseSteps
+    );
+    return this.parent;
+  }
+};
+var LoopBuilder = class {
+  parent;
+  condition;
+  bodySteps = [];
+  maxIter = 100;
+  constructor(parent, condition) {
+    this.parent = parent;
+    this.condition = condition;
+  }
+  /**
+   * Set loop body
+   */
+  do(builder) {
+    const subBuilder = new WorkflowBuilder(`loop-body-${nanoid(6)}`);
+    builder(subBuilder);
+    this.bodySteps = subBuilder.getSteps();
+    return this;
+  }
+  /**
+   * Set maximum iterations
+   */
+  maxIterations(max) {
+    this.maxIter = max;
+    return this;
+  }
+  /**
+   * Complete the loop and return to parent builder
+   */
+  endLoop() {
+    const loopConfig = {
+      name: `loop-${nanoid(6)}`,
+      condition: this.condition,
+      maxIterations: this.maxIter,
+      bodySteps: this.bodySteps.map((s) => s.config)
+    };
+    this.parent.addLoop(loopConfig, this.bodySteps);
+    return this.parent;
+  }
+};
+var WorkflowBuilder = class {
+  name;
+  description;
+  steps = [];
+  stepHandlers = /* @__PURE__ */ new Map();
+  checkpointEnabled = false;
+  checkpointInterval = "after-step";
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Set workflow description
+   */
+  describe(description) {
+    this.description = description;
+    return this;
+  }
+  /**
+   * Add a sequential step
+   */
+  addStep(name, handler, options = {}) {
+    const stepConfig = {
+      name,
+      type: "task",
+      ...options
+    };
+    this.steps.push({
+      type: "step",
+      config: stepConfig,
+      handler
+    });
+    this.stepHandlers.set(name, handler);
+    return this;
+  }
+  /**
+   * Add parallel steps
+   */
+  parallel(...steps) {
+    const parallelConfig = {
+      name: `parallel-${nanoid(6)}`,
+      steps: steps.map((s) => ({
+        name: s.name,
+        type: "task"
+      })),
+      waitFor: "all"
+    };
+    const children = steps.map((s) => ({
+      type: "step",
+      config: { name: s.name, type: "task" },
+      handler: s.handler
+    }));
+    for (const step of steps) {
+      this.stepHandlers.set(step.name, step.handler);
+    }
+    this.steps.push({
+      type: "parallel",
+      config: parallelConfig,
+      children
+    });
+    return this;
+  }
+  /**
+   * Add sequential steps
+   */
+  sequential(...steps) {
+    for (const step of steps) {
+      this.addStep(step.name, step.handler);
+    }
+    return this;
+  }
+  /**
+   * Add conditional branch
+   */
+  when(condition) {
+    return new BranchBuilder(this, condition);
+  }
+  /**
+   * Add a loop
+   */
+  while(condition) {
+    return new LoopBuilder(this, condition);
+  }
+  /**
+   * Add a checkpoint
+   */
+  checkpoint(name) {
+    this.steps.push({
+      type: "checkpoint",
+      config: {
+        name,
+        type: "checkpoint"
+      }
+    });
+    return this;
+  }
+  /**
+   * Enable automatic checkpointing
+   */
+  enableCheckpoints(interval = "after-step") {
+    this.checkpointEnabled = true;
+    this.checkpointInterval = interval;
+    return this;
+  }
+  /**
+   * Add a task step with agent assignment
+   */
+  task(name, description, options = {}) {
+    const stepConfig = {
+      name,
+      type: "task",
+      agentName: options.agent,
+      taskConfig: {
+        description,
+        expectedOutput: `Result of ${name}`,
+        requiredCapabilities: options.requiredCapabilities
+      },
+      timeoutMs: options.timeout
+    };
+    this.steps.push({
+      type: "step",
+      config: stepConfig
+    });
+    return this;
+  }
+  /**
+   * Add a crew step (delegate to entire crew)
+   */
+  crew(name, description, options = {}) {
+    const stepConfig = {
+      name,
+      type: "crew",
+      taskConfig: {
+        description,
+        expectedOutput: `Result of crew: ${name}`
+      },
+      timeoutMs: options.timeout
+    };
+    this.steps.push({
+      type: "step",
+      config: stepConfig
+    });
+    return this;
+  }
+  /**
+   * Internal: add conditional step
+   */
+  addConditional(config, thenSteps, elseSteps) {
+    this.steps.push({
+      type: "conditional",
+      config,
+      children: [...thenSteps, ...elseSteps]
+    });
+    for (const step of [...thenSteps, ...elseSteps]) {
+      if (step.handler) {
+        this.stepHandlers.set(
+          step.config.name,
+          step.handler
+        );
+      }
+    }
+  }
+  /**
+   * Internal: add loop step
+   */
+  addLoop(config, bodySteps) {
+    this.steps.push({
+      type: "loop",
+      config,
+      children: bodySteps
+    });
+    for (const step of bodySteps) {
+      if (step.handler) {
+        this.stepHandlers.set(
+          step.config.name,
+          step.handler
+        );
+      }
+    }
+  }
+  /**
+   * Internal: get steps for sub-builders
+   */
+  getSteps() {
+    return [...this.steps];
+  }
+  /**
+   * Build the workflow definition
+   */
+  build() {
+    return {
+      id: nanoid(),
+      name: this.name,
+      description: this.description,
+      steps: this.steps.map((s) => s.config),
+      handlers: this.stepHandlers,
+      checkpointing: this.checkpointEnabled ? { enabled: true, interval: this.checkpointInterval } : void 0
+    };
+  }
+  /**
+   * Get a step handler by name
+   */
+  getHandler(stepName) {
+    return this.stepHandlers.get(stepName);
+  }
+  /**
+   * Validate the workflow
+   */
+  validate() {
+    const errors = [];
+    if (this.steps.length === 0) {
+      errors.push("Workflow has no steps");
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const step of this.steps) {
+      const name = step.config.name;
+      if (names.has(name)) {
+        errors.push(`Duplicate step name: ${name}`);
+      }
+      names.add(name);
+    }
+    for (const step of this.steps) {
+      if (step.type === "step") {
+        const name = step.config.name;
+        if (!this.stepHandlers.has(name) && !step.config.agentName) {
+          errors.push(`Step "${name}" has no handler and no assigned agent`);
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+function workflow(name) {
+  return new WorkflowBuilder(name);
+}
+
+// src/workflows/DAGExecutor.ts
+import { nanoid as nanoid2 } from "nanoid";
+var DAGExecutor = class {
+  dag;
+  _handlers;
+  config;
+  nodeStates = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  aborted = false;
+  constructor(dag, handlers, config = {}) {
+    this.dag = dag;
+    this._handlers = handlers;
+    this.config = {
+      maxParallel: config.maxParallel ?? 5,
+      defaultTimeout: config.defaultTimeout ?? 6e4,
+      retryOnFailure: config.retryOnFailure ?? true,
+      maxRetries: config.maxRetries ?? 2,
+      enableCaching: config.enableCaching ?? false
+    };
+    for (const node of dag.nodes) {
+      this.nodeStates.set(node.id, {
+        status: "pending",
+        retries: 0
+      });
+    }
+  }
+  /**
+   * Execute the DAG
+   */
+  async execute(context) {
+    const startTime = Date.now();
+    const events = [];
+    for await (const event of this.executeStream(context)) {
+      events.push(event);
+    }
+    const results = /* @__PURE__ */ new Map();
+    for (const [nodeId, state] of this.nodeStates) {
+      if (state.result) {
+        results.set(nodeId, state.result);
+      }
+    }
+    const failedNodes = Array.from(this.nodeStates.entries()).filter(([, state]) => state.status === "failed").map(([id]) => id);
+    return {
+      success: failedNodes.length === 0 && !this.aborted,
+      results,
+      events,
+      executionTimeMs: Date.now() - startTime,
+      failedNodes: failedNodes.length > 0 ? failedNodes : void 0
+    };
+  }
+  /**
+   * Execute the DAG with streaming events
+   */
+  async *executeStream(context) {
+    this.aborted = false;
+    yield {
+      type: "dag:start",
+      dagId: this.dag.id,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    while (!this.isComplete()) {
+      if (this.aborted) {
+        yield {
+          type: "dag:aborted",
+          dagId: this.dag.id,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        break;
+      }
+      const readyNodes = this.getReadyNodes();
+      if (readyNodes.length === 0) {
+        const pendingCount = this.getPendingCount();
+        if (pendingCount > 0) {
+          yield {
+            type: "dag:error",
+            dagId: this.dag.id,
+            error: "Deadlock detected: no nodes ready but pending nodes exist",
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          break;
+        }
+        continue;
+      }
+      const batch = readyNodes.slice(0, this.config.maxParallel);
+      const promises = [];
+      for (const node of batch) {
+        this.updateNodeState(node.id, {
+          status: "running",
+          startTime: /* @__PURE__ */ new Date()
+        });
+        yield {
+          type: "node:start",
+          dagId: this.dag.id,
+          nodeId: node.id,
+          nodeName: node.name,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        promises.push(this.executeNode(node, context));
+      }
+      const results = await Promise.all(promises);
+      for (const { nodeId, result, error } of results) {
+        const node = this.dag.nodes.find((n) => n.id === nodeId);
+        if (error) {
+          const state = this.nodeStates.get(nodeId);
+          if (this.config.retryOnFailure && state.retries < this.config.maxRetries) {
+            this.updateNodeState(nodeId, {
+              status: "pending",
+              retries: state.retries + 1
+            });
+            yield {
+              type: "node:retry",
+              dagId: this.dag.id,
+              nodeId,
+              nodeName: node.name,
+              attempt: state.retries + 1,
+              error,
+              timestamp: /* @__PURE__ */ new Date()
+            };
+          } else {
+            this.updateNodeState(nodeId, {
+              status: "failed",
+              error,
+              endTime: /* @__PURE__ */ new Date()
+            });
+            yield {
+              type: "node:error",
+              dagId: this.dag.id,
+              nodeId,
+              nodeName: node.name,
+              error,
+              timestamp: /* @__PURE__ */ new Date()
+            };
+            for (const depId of this.getDependentNodes(nodeId)) {
+              this.updateNodeState(depId, { status: "skipped" });
+              yield {
+                type: "node:skipped",
+                dagId: this.dag.id,
+                nodeId: depId,
+                nodeName: this.dag.nodes.find((n) => n.id === depId)?.name ?? "",
+                reason: `Dependency ${node.name} failed`,
+                timestamp: /* @__PURE__ */ new Date()
+              };
+            }
+          }
+        } else {
+          this.updateNodeState(nodeId, {
+            status: "completed",
+            result,
+            endTime: /* @__PURE__ */ new Date()
+          });
+          if (this.config.enableCaching) {
+            this.cache.set(nodeId, result);
+          }
+          yield {
+            type: "node:complete",
+            dagId: this.dag.id,
+            nodeId,
+            nodeName: node.name,
+            result,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+        }
+      }
+    }
+    yield {
+      type: "dag:complete",
+      dagId: this.dag.id,
+      success: this.isSuccessful(),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Execute a single node
+   */
+  async executeNode(node, context) {
+    if (this.config.enableCaching && this.cache.has(node.id)) {
+      return { nodeId: node.id, result: this.cache.get(node.id) };
+    }
+    const nodeName = node.name ?? node.id;
+    const handler = this._handlers.get(nodeName);
+    if (!handler) {
+      return {
+        nodeId: node.id,
+        result: null,
+        error: `No handler found for node: ${nodeName}`
+      };
+    }
+    const workflowContext = this.buildWorkflowContext(node, context);
+    const timeout = node.stepConfig?.timeoutMs ?? this.config.defaultTimeout;
+    try {
+      const result = await Promise.race([
+        handler(workflowContext),
+        this.createTimeout(timeout, nodeName)
+      ]);
+      return { nodeId: node.id, result };
+    } catch (error) {
+      return {
+        nodeId: node.id,
+        result: null,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Build workflow context for a node
+   */
+  buildWorkflowContext(node, context) {
+    const stepResults = /* @__PURE__ */ new Map();
+    for (const depId of node.dependencies ?? []) {
+      const state = this.nodeStates.get(depId);
+      if (state?.result) {
+        const depNode = this.dag.nodes.find((n) => n.id === depId);
+        if (depNode) {
+          const depNodeName = depNode.name ?? depNode.id;
+          stepResults.set(depNodeName, state.result);
+        }
+      }
+    }
+    return {
+      stepName: node.name ?? node.id,
+      stepResults,
+      variables: new Map(context.entries()),
+      setVariable: (key, value) => context.set(key, value),
+      getVariable: (key) => context.get(key),
+      emit: (event) => context.emit(event),
+      isAborted: () => context.isAborted || this.aborted
+    };
+  }
+  /**
+   * Create a timeout promise
+   */
+  createTimeout(ms, stepName) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Step "${stepName}" timed out after ${ms}ms`));
+      }, ms);
+    });
+  }
+  /**
+   * Get nodes ready for execution
+   */
+  getReadyNodes() {
+    const ready = [];
+    for (const node of this.dag.nodes) {
+      const state = this.nodeStates.get(node.id);
+      if (state?.status !== "pending") continue;
+      const depsCompleted = (node.dependencies ?? []).every((depId) => {
+        const depState = this.nodeStates.get(depId);
+        return depState?.status === "completed";
+      });
+      if (depsCompleted) {
+        ready.push(node);
+      }
+    }
+    return ready;
+  }
+  /**
+   * Get nodes that depend on a given node
+   */
+  getDependentNodes(nodeId) {
+    const dependents = [];
+    for (const node of this.dag.nodes) {
+      if (node.dependencies?.includes(nodeId)) {
+        dependents.push(node.id);
+        dependents.push(...this.getDependentNodes(node.id));
+      }
+    }
+    return [...new Set(dependents)];
+  }
+  /**
+   * Update node state
+   */
+  updateNodeState(nodeId, update) {
+    const current = this.nodeStates.get(nodeId) ?? {
+      status: "pending",
+      retries: 0
+    };
+    this.nodeStates.set(nodeId, { ...current, ...update });
+  }
+  /**
+   * Check if all nodes are done
+   */
+  isComplete() {
+    for (const state of this.nodeStates.values()) {
+      if (state.status === "pending" || state.status === "running") {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if execution was successful
+   */
+  isSuccessful() {
+    for (const state of this.nodeStates.values()) {
+      if (state.status === "failed") {
+        return false;
+      }
+    }
+    return !this.aborted;
+  }
+  /**
+   * Get count of pending nodes
+   */
+  getPendingCount() {
+    let count = 0;
+    for (const state of this.nodeStates.values()) {
+      if (state.status === "pending") count++;
+    }
+    return count;
+  }
+  /**
+   * Abort execution
+   */
+  abort() {
+    this.aborted = true;
+  }
+  /**
+   * Validate the DAG
+   */
+  validate() {
+    const errors = [];
+    const warnings = [];
+    if (this.dag.nodes.length === 0) {
+      errors.push("DAG has no nodes");
+    }
+    const nodeIds = new Set(this.dag.nodes.map((n) => n.id));
+    for (const node of this.dag.nodes) {
+      const nodeName = node.name ?? node.id;
+      for (const depId of node.dependencies ?? []) {
+        if (!nodeIds.has(depId)) {
+          errors.push(`Node "${nodeName}" has missing dependency: ${depId}`);
+        }
+      }
+    }
+    const cycle = this.detectCycle();
+    if (cycle) {
+      errors.push(`Cycle detected: ${cycle.join(" -> ")}`);
+    }
+    for (const node of this.dag.nodes) {
+      const nodeName = node.name ?? node.id;
+      if (!this._handlers.has(nodeName)) {
+        warnings.push(`Node "${nodeName}" has no handler`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Detect cycles in the DAG
+   */
+  detectCycle() {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const path = [];
+    const dfs = (nodeId) => {
+      visited.add(nodeId);
+      recursionStack.add(nodeId);
+      path.push(nodeId);
+      const node = this.dag.nodes.find((n) => n.id === nodeId);
+      if (node) {
+        for (const depId of node.dependencies ?? []) {
+          if (!visited.has(depId)) {
+            if (dfs(depId)) return true;
+          } else if (recursionStack.has(depId)) {
+            path.push(depId);
+            return true;
+          }
+        }
+      }
+      recursionStack.delete(nodeId);
+      path.pop();
+      return false;
+    };
+    for (const node of this.dag.nodes) {
+      if (!visited.has(node.id)) {
+        if (dfs(node.id)) {
+          const cycleStart = path.indexOf(path[path.length - 1]);
+          return path.slice(cycleStart).map((id) => this.dag.nodes.find((n) => n.id === id)?.name ?? id);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get execution state for all nodes
+   */
+  getState() {
+    return new Map(this.nodeStates);
+  }
+  /**
+   * Get execution statistics
+   */
+  getStatistics() {
+    let completed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let pending = 0;
+    let running = 0;
+    for (const state of this.nodeStates.values()) {
+      switch (state.status) {
+        case "completed":
+          completed++;
+          break;
+        case "failed":
+          failed++;
+          break;
+        case "skipped":
+          skipped++;
+          break;
+        case "pending":
+          pending++;
+          break;
+        case "running":
+          running++;
+          break;
+      }
+    }
+    return {
+      totalNodes: this.dag.nodes.length,
+      completed,
+      failed,
+      skipped,
+      pending,
+      running
+    };
+  }
+};
+function createDAGFromSteps(steps, _handlers) {
+  const nodes = [];
+  const previousNodeIds = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const nodeId = nanoid2();
+    const node = {
+      id: nodeId,
+      name: step.name,
+      stepConfig: step,
+      dependencies: [...previousNodeIds]
+      // Sequential by default
+    };
+    nodes.push(node);
+    previousNodeIds.length = 0;
+    previousNodeIds.push(nodeId);
+  }
+  return {
+    id: nanoid2(),
+    nodes,
+    edges: []
+  };
+}
+function createDAGExecutor(dag, handlers, config) {
+  return new DAGExecutor(dag, handlers, config);
+}
+
+// src/workflows/ParallelExecution.ts
+var ParallelExecutor = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxConcurrency: options.maxConcurrency ?? 5,
+      taskTimeout: options.taskTimeout ?? 6e4,
+      failFast: options.failFast ?? false,
+      continueOnError: options.continueOnError ?? true
+    };
+  }
+  /**
+   * Execute tasks in parallel
+   */
+  async executeBatch(tasks, executor, _context) {
+    const startTime = Date.now();
+    const results = [];
+    let aborted = false;
+    const semaphore = new Semaphore(this.options.maxConcurrency);
+    const taskPromises = tasks.map(async (task) => {
+      if (aborted) {
+        return {
+          taskId: task.id,
+          status: "failed",
+          error: "Batch aborted",
+          executionTimeMs: 0
+        };
+      }
+      await semaphore.acquire();
+      const taskStartTime = Date.now();
+      try {
+        const result = await Promise.race([
+          executor(task),
+          this.createTimeout(this.options.taskTimeout)
+        ]);
+        return {
+          taskId: task.id,
+          status: "success",
+          result,
+          executionTimeMs: Date.now() - taskStartTime
+        };
+      } catch (error) {
+        const isTimeout = error instanceof TimeoutError;
+        if (this.options.failFast && !isTimeout) {
+          aborted = true;
+        }
+        return {
+          taskId: task.id,
+          status: isTimeout ? "timeout" : "failed",
+          error: error instanceof Error ? error.message : String(error),
+          executionTimeMs: Date.now() - taskStartTime
+        };
+      } finally {
+        semaphore.release();
+      }
+    });
+    const parallelResults = await Promise.all(taskPromises);
+    results.push(...parallelResults);
+    const successCount = results.filter((r) => r.status === "success").length;
+    const failureCount = results.filter((r) => r.status !== "success").length;
+    return {
+      results,
+      totalTimeMs: Date.now() - startTime,
+      successCount,
+      failureCount,
+      allSuccessful: failureCount === 0
+    };
+  }
+  /**
+   * Execute tasks with agent assignment
+   */
+  async executeWithAgents(tasks, agents, context) {
+    const agentQueue = new AgentPool(agents);
+    const executor = async (task) => {
+      const agent = await agentQueue.acquire();
+      try {
+        return await agent.executeTask(task);
+      } finally {
+        agentQueue.release(agent);
+      }
+    };
+    return this.executeBatch(tasks, executor, context);
+  }
+  /**
+   * Map over items with parallel execution
+   */
+  async map(items, mapper) {
+    const semaphore = new Semaphore(this.options.maxConcurrency);
+    let aborted = false;
+    const results = await Promise.all(
+      items.map(async (item, index) => {
+        if (aborted) {
+          return { item, error: "Aborted" };
+        }
+        await semaphore.acquire();
+        try {
+          const result = await mapper(item, index);
+          return { item, result };
+        } catch (error) {
+          if (this.options.failFast) {
+            aborted = true;
+          }
+          return {
+            item,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        } finally {
+          semaphore.release();
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Execute tasks in batches
+   */
+  async executeBatches(items, batchSize, processor) {
+    const results = [];
+    const batches = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      batches.push(items.slice(i, i + batchSize));
+    }
+    const semaphore = new Semaphore(this.options.maxConcurrency);
+    await Promise.all(
+      batches.map(async (batch) => {
+        await semaphore.acquire();
+        try {
+          const batchResults = await processor(batch);
+          results.push(...batchResults);
+        } finally {
+          semaphore.release();
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Create a timeout promise
+   */
+  createTimeout(ms) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new TimeoutError(`Task timed out after ${ms}ms`));
+      }, ms);
+    });
+  }
+};
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+    });
+  }
+  release() {
+    if (this.waiting.length > 0) {
+      const next = this.waiting.shift();
+      next();
+    } else {
+      this.permits++;
+    }
+  }
+};
+var AgentPool = class {
+  available;
+  waiting = [];
+  constructor(agents) {
+    this.available = [...agents];
+  }
+  async acquire() {
+    if (this.available.length > 0) {
+      return this.available.pop();
+    }
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+    });
+  }
+  release(agent) {
+    if (this.waiting.length > 0) {
+      const next = this.waiting.shift();
+      next(agent);
+    } else {
+      this.available.push(agent);
+    }
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+function createParallelExecutor(options) {
+  return new ParallelExecutor(options);
+}
+
+// src/workflows/Checkpointing.ts
+import { nanoid as nanoid3 } from "nanoid";
+var InMemoryCheckpointStorage = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  save(checkpoint) {
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    return Promise.resolve(checkpoint.id);
+  }
+  load(checkpointId) {
+    return Promise.resolve(this.checkpoints.get(checkpointId) ?? null);
+  }
+  list(workflowId) {
+    const ids = [];
+    for (const [id, checkpoint] of this.checkpoints) {
+      if (checkpoint.workflowId === workflowId) {
+        ids.push(id);
+      }
+    }
+    return Promise.resolve(ids);
+  }
+  delete(checkpointId) {
+    this.checkpoints.delete(checkpointId);
+    return Promise.resolve();
+  }
+  deleteAll(workflowId) {
+    for (const [id, checkpoint] of this.checkpoints) {
+      if (checkpoint.workflowId === workflowId) {
+        this.checkpoints.delete(id);
+      }
+    }
+    return Promise.resolve();
+  }
+  clear() {
+    this.checkpoints.clear();
+  }
+};
+var CheckpointManager = class {
+  storage;
+  config;
+  autoCheckpointTimer;
+  stepCounter = 0;
+  currentWorkflowId;
+  constructor(config = {}) {
+    this.storage = config.storage ?? new InMemoryCheckpointStorage();
+    this.config = {
+      autoCheckpointInterval: config.autoCheckpointInterval ?? "after-step",
+      maxCheckpoints: config.maxCheckpoints ?? 10,
+      compress: config.compress ?? false
+    };
+  }
+  /**
+   * Save a checkpoint
+   */
+  async save(workflowId, state) {
+    const checkpoint = {
+      id: nanoid3(),
+      workflowId,
+      timestamp: /* @__PURE__ */ new Date(),
+      stepIndex: state.currentStepIndex,
+      stepResults: state.stepResults,
+      variables: Object.fromEntries(state.variables),
+      metadata: state.metadata
+    };
+    await this.storage.save(checkpoint);
+    await this.cleanupOldCheckpoints(workflowId);
+    return checkpoint;
+  }
+  /**
+   * Load a checkpoint
+   */
+  async load(checkpointId) {
+    return this.storage.load(checkpointId);
+  }
+  /**
+   * Load the latest checkpoint for a workflow
+   */
+  async loadLatest(workflowId) {
+    const checkpointIds = await this.storage.list(workflowId);
+    if (checkpointIds.length === 0) {
+      return null;
+    }
+    let latest = null;
+    for (const id of checkpointIds) {
+      const checkpoint = await this.storage.load(id);
+      if (checkpoint) {
+        if (!latest || checkpoint.timestamp > latest.timestamp) {
+          latest = checkpoint;
+        }
+      }
+    }
+    return latest;
+  }
+  /**
+   * Delete a checkpoint
+   */
+  async delete(checkpointId) {
+    await this.storage.delete(checkpointId);
+  }
+  /**
+   * Delete all checkpoints for a workflow
+   */
+  async deleteAll(workflowId) {
+    await this.storage.deleteAll(workflowId);
+  }
+  /**
+   * List checkpoints for a workflow
+   */
+  async list(workflowId) {
+    const ids = await this.storage.list(workflowId);
+    const checkpoints = [];
+    for (const id of ids) {
+      const checkpoint = await this.storage.load(id);
+      if (checkpoint) {
+        checkpoints.push(checkpoint);
+      }
+    }
+    checkpoints.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    return checkpoints;
+  }
+  /**
+   * Enable automatic checkpointing
+   */
+  enableAutoCheckpoint(workflowId, getState) {
+    this.currentWorkflowId = workflowId;
+    this.stepCounter = 0;
+    if (typeof this.config.autoCheckpointInterval === "number") {
+      this.autoCheckpointTimer = setInterval(() => {
+        void (async () => {
+          try {
+            await this.save(workflowId, getState());
+          } catch (error) {
+            console.error("Auto-checkpoint failed:", error);
+          }
+        })();
+      }, this.config.autoCheckpointInterval);
+    }
+  }
+  /**
+   * Disable automatic checkpointing
+   */
+  disableAutoCheckpoint() {
+    if (this.autoCheckpointTimer) {
+      clearInterval(this.autoCheckpointTimer);
+      this.autoCheckpointTimer = void 0;
+    }
+    this.currentWorkflowId = void 0;
+  }
+  /**
+   * Notify that a step completed (for step-based checkpointing)
+   */
+  async onStepComplete(workflowId, state) {
+    if (this.config.autoCheckpointInterval === "after-step") {
+      await this.save(workflowId, state);
+    }
+    this.stepCounter++;
+  }
+  /**
+   * Restore workflow state from checkpoint
+   */
+  async restore(checkpointId) {
+    const checkpoint = await this.load(checkpointId);
+    if (!checkpoint) {
+      return null;
+    }
+    return {
+      currentStepIndex: checkpoint.stepIndex ?? 0,
+      stepResults: checkpoint.stepResults instanceof Map ? checkpoint.stepResults : new Map(Object.entries(checkpoint.stepResults)),
+      variables: new Map(Object.entries(checkpoint.variables)),
+      metadata: checkpoint.metadata ?? {}
+    };
+  }
+  /**
+   * Cleanup old checkpoints
+   */
+  async cleanupOldCheckpoints(workflowId) {
+    const checkpoints = await this.list(workflowId);
+    if (checkpoints.length > this.config.maxCheckpoints) {
+      const toDelete = checkpoints.slice(this.config.maxCheckpoints);
+      for (const checkpoint of toDelete) {
+        await this.storage.delete(checkpoint.id);
+      }
+    }
+  }
+  /**
+   * Export checkpoints for a workflow
+   */
+  async export(workflowId) {
+    const checkpoints = await this.list(workflowId);
+    return JSON.stringify(checkpoints, null, 2);
+  }
+  /**
+   * Import checkpoints
+   */
+  async import(data) {
+    const checkpoints = JSON.parse(data);
+    let count = 0;
+    for (const checkpoint of checkpoints) {
+      checkpoint.timestamp = new Date(checkpoint.timestamp);
+      await this.storage.save(checkpoint);
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Get statistics
+   */
+  async getStatistics(workflowId) {
+    const checkpoints = await this.list(workflowId);
+    let totalSize = 0;
+    let oldestTimestamp = null;
+    let newestTimestamp = null;
+    for (const checkpoint of checkpoints) {
+      totalSize += JSON.stringify(checkpoint).length;
+      if (!oldestTimestamp || checkpoint.timestamp < oldestTimestamp) {
+        oldestTimestamp = checkpoint.timestamp;
+      }
+      if (!newestTimestamp || checkpoint.timestamp > newestTimestamp) {
+        newestTimestamp = checkpoint.timestamp;
+      }
+    }
+    return {
+      checkpointCount: checkpoints.length,
+      estimatedSizeBytes: totalSize,
+      oldestCheckpoint: oldestTimestamp,
+      newestCheckpoint: newestTimestamp
+    };
+  }
+};
+function createCheckpointManager(config) {
+  return new CheckpointManager(config);
+}
+
+// src/memory/SharedMemory.ts
+import { EventEmitter } from "eventemitter3";
+var SharedMemory = class extends EventEmitter {
+  namespaces = /* @__PURE__ */ new Map();
+  agentNamespaces = /* @__PURE__ */ new Map();
+  history = [];
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      maxEntriesPerNamespace: config.maxEntriesPerNamespace ?? 1e3,
+      trackHistory: config.trackHistory ?? true,
+      maxHistoryEntries: config.maxHistoryEntries ?? 100,
+      persist: config.persist ?? false
+    };
+    this.createNamespace("shared");
+  }
+  // ============ Shared Operations ============
+  /**
+   * Set a shared value
+   */
+  setShared(key, value, agent) {
+    this.set("shared", key, value, agent);
+  }
+  /**
+   * Get a shared value
+   */
+  getShared(key) {
+    return this.get("shared", key);
+  }
+  /**
+   * Delete a shared value
+   */
+  deleteShared(key, agent) {
+    return this.delete("shared", key, agent);
+  }
+  /**
+   * Check if shared key exists
+   */
+  hasShared(key) {
+    return this.has("shared", key);
+  }
+  /**
+   * Get all shared keys
+   */
+  getSharedKeys() {
+    return this.getKeys("shared");
+  }
+  // ============ Agent-Specific Operations ============
+  /**
+   * Set a value for a specific agent
+   */
+  setForAgent(agentName, key, value) {
+    if (!this.agentNamespaces.has(agentName)) {
+      const namespace2 = `agent:${agentName}`;
+      this.createNamespace(namespace2);
+      this.agentNamespaces.set(agentName, namespace2);
+    }
+    const namespace = this.agentNamespaces.get(agentName);
+    this.set(namespace, key, value, agentName);
+  }
+  /**
+   * Get a value for a specific agent
+   */
+  getForAgent(agentName, key) {
+    const namespace = this.agentNamespaces.get(agentName);
+    if (!namespace) return void 0;
+    return this.get(namespace, key);
+  }
+  /**
+   * Delete a value for a specific agent
+   */
+  deleteForAgent(agentName, key) {
+    const namespace = this.agentNamespaces.get(agentName);
+    if (!namespace) return false;
+    return this.delete(namespace, key, agentName);
+  }
+  /**
+   * Get all keys for an agent
+   */
+  getAgentKeys(agentName) {
+    const namespace = this.agentNamespaces.get(agentName);
+    if (!namespace) return [];
+    return this.getKeys(namespace);
+  }
+  /**
+   * Clear all agent data
+   */
+  clearAgent(agentName) {
+    const namespace = this.agentNamespaces.get(agentName);
+    if (namespace) {
+      this.clearNamespace(namespace, agentName);
+    }
+  }
+  // ============ Broadcast Operations ============
+  /**
+   * Broadcast a value to all agents
+   */
+  broadcast(key, value, fromAgent) {
+    this.setShared(key, value, fromAgent);
+    this.emit("change", {
+      type: "set",
+      key: `broadcast:${key}`,
+      value,
+      agent: fromAgent,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  // ============ Namespace Operations ============
+  /**
+   * Create a namespace
+   */
+  createNamespace(name) {
+    if (this.namespaces.has(name)) {
+      return this.namespaces.get(name);
+    }
+    const namespace = {
+      name,
+      data: /* @__PURE__ */ new Map(),
+      created: /* @__PURE__ */ new Date(),
+      lastAccessed: /* @__PURE__ */ new Date()
+    };
+    this.namespaces.set(name, namespace);
+    this.emit("namespaceCreated", name);
+    return namespace;
+  }
+  /**
+   * Delete a namespace
+   */
+  deleteNamespace(name) {
+    if (name === "shared") {
+      throw new Error("Cannot delete shared namespace");
+    }
+    if (!this.namespaces.has(name)) {
+      return false;
+    }
+    this.namespaces.delete(name);
+    this.emit("namespaceDeleted", name);
+    return true;
+  }
+  /**
+   * Clear a namespace
+   */
+  clearNamespace(name, agent) {
+    const namespace = this.namespaces.get(name);
+    if (namespace) {
+      namespace.data.clear();
+      namespace.lastAccessed = /* @__PURE__ */ new Date();
+      if (this.config.trackHistory) {
+        this.addToHistory({
+          type: "clear",
+          agent,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+  }
+  /**
+   * Get namespace names
+   */
+  getNamespaces() {
+    return Array.from(this.namespaces.keys());
+  }
+  // ============ Low-Level Operations ============
+  /**
+   * Set a value in a namespace
+   */
+  set(namespace, key, value, agent) {
+    const ns = this.namespaces.get(namespace);
+    if (!ns) {
+      throw new Error(`Namespace not found: ${namespace}`);
+    }
+    if (ns.data.size >= this.config.maxEntriesPerNamespace && !ns.data.has(key)) {
+      const firstKey = ns.data.keys().next().value;
+      if (firstKey !== void 0) {
+        ns.data.delete(firstKey);
+      }
+    }
+    const previousValue = ns.data.get(key);
+    ns.data.set(key, value);
+    ns.lastAccessed = /* @__PURE__ */ new Date();
+    if (this.config.trackHistory) {
+      this.addToHistory({
+        type: "set",
+        key: `${namespace}:${key}`,
+        value,
+        previousValue,
+        agent,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+    this.emit("change", {
+      type: "set",
+      key: `${namespace}:${key}`,
+      value,
+      previousValue,
+      agent,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Get a value from a namespace
+   */
+  get(namespace, key) {
+    const ns = this.namespaces.get(namespace);
+    if (!ns) return void 0;
+    ns.lastAccessed = /* @__PURE__ */ new Date();
+    return ns.data.get(key);
+  }
+  /**
+   * Delete a value from a namespace
+   */
+  delete(namespace, key, agent) {
+    const ns = this.namespaces.get(namespace);
+    if (!ns) return false;
+    const previousValue = ns.data.get(key);
+    const deleted = ns.data.delete(key);
+    ns.lastAccessed = /* @__PURE__ */ new Date();
+    if (deleted && this.config.trackHistory) {
+      this.addToHistory({
+        type: "delete",
+        key: `${namespace}:${key}`,
+        previousValue,
+        agent,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+    if (deleted) {
+      this.emit("change", {
+        type: "delete",
+        key: `${namespace}:${key}`,
+        previousValue,
+        agent,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+    return deleted;
+  }
+  /**
+   * Check if key exists in namespace
+   */
+  has(namespace, key) {
+    const ns = this.namespaces.get(namespace);
+    if (!ns) return false;
+    return ns.data.has(key);
+  }
+  /**
+   * Get all keys in a namespace
+   */
+  getKeys(namespace) {
+    const ns = this.namespaces.get(namespace);
+    if (!ns) return [];
+    return Array.from(ns.data.keys());
+  }
+  // ============ History ============
+  /**
+   * Add to history
+   */
+  addToHistory(event) {
+    this.history.push(event);
+    if (this.history.length > this.config.maxHistoryEntries) {
+      this.history.shift();
+    }
+  }
+  /**
+   * Get change history
+   */
+  getHistory(filter) {
+    let events = [...this.history];
+    if (filter) {
+      if (filter.agent) {
+        events = events.filter((e) => e.agent === filter.agent);
+      }
+      if (filter.key) {
+        events = events.filter((e) => e.key?.includes(filter.key));
+      }
+      if (filter.type) {
+        events = events.filter((e) => e.type === filter.type);
+      }
+      if (filter.since) {
+        events = events.filter((e) => e.timestamp >= filter.since);
+      }
+    }
+    return events;
+  }
+  /**
+   * Clear history
+   */
+  clearHistory() {
+    this.history.length = 0;
+  }
+  // ============ Serialization ============
+  /**
+   * Export all data
+   */
+  export() {
+    const data = {};
+    for (const [name, namespace] of this.namespaces) {
+      data[name] = Object.fromEntries(namespace.data);
+    }
+    return data;
+  }
+  /**
+   * Import data
+   */
+  import(data) {
+    for (const [name, entries] of Object.entries(data)) {
+      if (!this.namespaces.has(name)) {
+        this.createNamespace(name);
+      }
+      const namespace = this.namespaces.get(name);
+      for (const [key, value] of Object.entries(entries)) {
+        namespace.data.set(key, value);
+      }
+    }
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    for (const namespace of this.namespaces.values()) {
+      namespace.data.clear();
+    }
+    this.history.length = 0;
+  }
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    const entriesByNamespace = {};
+    let totalEntries = 0;
+    for (const [name, namespace] of this.namespaces) {
+      entriesByNamespace[name] = namespace.data.size;
+      totalEntries += namespace.data.size;
+    }
+    return {
+      totalNamespaces: this.namespaces.size,
+      totalEntries,
+      entriesByNamespace,
+      historyEntries: this.history.length
+    };
+  }
+};
+function createSharedMemory(config) {
+  return new SharedMemory(config);
+}
+
+// src/memory/ConversationHistory.ts
+import { nanoid as nanoid4 } from "nanoid";
+var ConversationHistory = class {
+  agentMessages = /* @__PURE__ */ new Map();
+  threads = /* @__PURE__ */ new Map();
+  allMessages = [];
+  config;
+  currentThreadId;
+  constructor(config = {}) {
+    this.config = {
+      maxMessagesPerAgent: config.maxMessagesPerAgent ?? 100,
+      maxTotalMessages: config.maxTotalMessages ?? 1e3,
+      enableThreads: config.enableThreads ?? true,
+      autoSummarize: config.autoSummarize ?? false
+    };
+  }
+  // ============ Message Operations ============
+  /**
+   * Add a message
+   */
+  addMessage(agentName, message) {
+    const fullMessage = {
+      ...message,
+      id: nanoid4(),
+      agentName,
+      timestamp: /* @__PURE__ */ new Date(),
+      threadId: this.currentThreadId
+    };
+    if (!this.agentMessages.has(agentName)) {
+      this.agentMessages.set(agentName, []);
+    }
+    const agentMsgs = this.agentMessages.get(agentName);
+    agentMsgs.push(fullMessage);
+    if (agentMsgs.length > this.config.maxMessagesPerAgent) {
+      agentMsgs.shift();
+    }
+    this.allMessages.push(fullMessage);
+    if (this.allMessages.length > this.config.maxTotalMessages) {
+      this.allMessages.shift();
+    }
+    if (this.config.enableThreads && this.currentThreadId) {
+      const thread = this.threads.get(this.currentThreadId);
+      if (thread) {
+        thread.messages.push(fullMessage);
+        thread.lastActivity = /* @__PURE__ */ new Date();
+        if (!thread.participants.includes(agentName)) {
+          thread.participants.push(agentName);
+        }
+      }
+    }
+    return fullMessage;
+  }
+  /**
+   * Add a user message
+   */
+  addUserMessage(content, agentName) {
+    return this.addMessage(agentName ?? "user", {
+      role: "user",
+      content
+    });
+  }
+  /**
+   * Add an assistant message
+   */
+  addAssistantMessage(agentName, content, metadata) {
+    return this.addMessage(agentName, {
+      role: "assistant",
+      content,
+      metadata
+    });
+  }
+  /**
+   * Add a system message
+   */
+  addSystemMessage(agentName, content) {
+    return this.addMessage(agentName, {
+      role: "system",
+      content
+    });
+  }
+  /**
+   * Add a tool message
+   */
+  addToolMessage(agentName, toolName, input, output) {
+    return this.addMessage(agentName, {
+      role: "tool",
+      content: typeof output === "string" ? output : JSON.stringify(output),
+      metadata: {
+        toolCall: {
+          name: toolName,
+          input,
+          output
+        }
+      }
+    });
+  }
+  // ============ Retrieval ============
+  /**
+   * Get messages for an agent
+   */
+  getAgentHistory(agentName, options = {}) {
+    let messages = this.agentMessages.get(agentName) ?? [];
+    if (options.since) {
+      messages = messages.filter((m) => m.timestamp >= options.since);
+    }
+    if (options.role) {
+      messages = messages.filter((m) => m.role === options.role);
+    }
+    if (options.limit) {
+      messages = messages.slice(-options.limit);
+    }
+    return [...messages];
+  }
+  /**
+   * Get full history
+   */
+  getFullHistory(options = {}) {
+    let messages = [...this.allMessages];
+    if (options.since) {
+      messages = messages.filter((m) => m.timestamp >= options.since);
+    }
+    if (options.agents) {
+      messages = messages.filter((m) => options.agents.includes(m.agentName));
+    }
+    if (options.limit) {
+      messages = messages.slice(-options.limit);
+    }
+    return messages;
+  }
+  /**
+   * Get conversation between agents
+   */
+  getConversation(agent1, agent2, limit) {
+    const messages = this.allMessages.filter(
+      (m) => m.agentName === agent1 || m.agentName === agent2
+    );
+    if (limit) {
+      return messages.slice(-limit);
+    }
+    return [...messages];
+  }
+  /**
+   * Get recent messages
+   */
+  getRecent(count = 10) {
+    return this.allMessages.slice(-count);
+  }
+  /**
+   * Search history
+   */
+  searchHistory(query, options = {}) {
+    const searchQuery = options.caseSensitive ? query : query.toLowerCase();
+    let results = this.allMessages.filter((m) => {
+      const content = options.caseSensitive ? m.content : m.content.toLowerCase();
+      return content.includes(searchQuery);
+    });
+    if (options.agent) {
+      results = results.filter((m) => m.agentName === options.agent);
+    }
+    if (options.limit) {
+      results = results.slice(-options.limit);
+    }
+    return results;
+  }
+  // ============ Thread Operations ============
+  /**
+   * Create a new thread
+   */
+  createThread(title, participants = []) {
+    const thread = {
+      id: nanoid4(),
+      title,
+      participants,
+      messages: [],
+      created: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date()
+    };
+    this.threads.set(thread.id, thread);
+    this.currentThreadId = thread.id;
+    return thread;
+  }
+  /**
+   * Switch to a thread
+   */
+  switchThread(threadId) {
+    if (this.threads.has(threadId)) {
+      this.currentThreadId = threadId;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get current thread
+   */
+  getCurrentThread() {
+    if (!this.currentThreadId) return void 0;
+    return this.threads.get(this.currentThreadId);
+  }
+  /**
+   * Get a thread
+   */
+  getThread(threadId) {
+    return this.threads.get(threadId);
+  }
+  /**
+   * Get all threads
+   */
+  getThreads() {
+    return Array.from(this.threads.values()).sort(
+      (a, b) => b.lastActivity.getTime() - a.lastActivity.getTime()
+    );
+  }
+  /**
+   * Delete a thread
+   */
+  deleteThread(threadId) {
+    if (this.currentThreadId === threadId) {
+      this.currentThreadId = void 0;
+    }
+    return this.threads.delete(threadId);
+  }
+  // ============ Context Building ============
+  /**
+   * Build context for an agent (recent conversation)
+   */
+  buildAgentContext(agentName, maxMessages = 20) {
+    return this.getAgentHistory(agentName, { limit: maxMessages });
+  }
+  /**
+   * Build context for LLM (formatted messages)
+   */
+  buildLLMContext(agentName, options = {}) {
+    const messages = this.getAgentHistory(agentName, {
+      limit: options.maxMessages ?? 20
+    });
+    return messages.filter((m) => {
+      if (m.role === "system" && !options.includeSystem) return false;
+      if (m.role === "tool" && !options.includeTools) return false;
+      return true;
+    }).map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+  /**
+   * Summarize conversation (placeholder for LLM summarization)
+   */
+  summarize(messages) {
+    const agentSummaries = {};
+    let totalMessages = 0;
+    let toolCalls = 0;
+    for (const msg of messages) {
+      totalMessages++;
+      if (msg.agentName) {
+        const agent = msg.agentName;
+        agentSummaries[agent] = (agentSummaries[agent] ?? 0) + 1;
+      }
+      if (msg.metadata?.toolCall) {
+        toolCalls++;
+      }
+    }
+    const parts = [];
+    parts.push(`Conversation with ${totalMessages} messages`);
+    if (Object.keys(agentSummaries).length > 0) {
+      const agentList = Object.entries(agentSummaries).map(([name, count]) => `${name} (${count})`).join(", ");
+      parts.push(`Participants: ${agentList}`);
+    }
+    if (toolCalls > 0) {
+      parts.push(`Tool calls: ${toolCalls}`);
+    }
+    return parts.join(". ");
+  }
+  // ============ Utilities ============
+  /**
+   * Get all participating agents
+   */
+  getParticipants() {
+    return Array.from(this.agentMessages.keys());
+  }
+  /**
+   * Get message count
+   */
+  getMessageCount(agentName) {
+    if (agentName) {
+      return this.agentMessages.get(agentName)?.length ?? 0;
+    }
+    return this.allMessages.length;
+  }
+  /**
+   * Clear all history
+   */
+  clear() {
+    this.agentMessages.clear();
+    this.threads.clear();
+    this.allMessages.length = 0;
+    this.currentThreadId = void 0;
+  }
+  /**
+   * Clear history for an agent
+   */
+  clearAgent(agentName) {
+    this.agentMessages.delete(agentName);
+    for (let i = this.allMessages.length - 1; i >= 0; i--) {
+      if (this.allMessages[i].agentName === agentName) {
+        this.allMessages.splice(i, 1);
+      }
+    }
+  }
+  /**
+   * Export history
+   */
+  export() {
+    return {
+      messages: [...this.allMessages],
+      threads: Array.from(this.threads.values())
+    };
+  }
+  /**
+   * Import history
+   */
+  import(data) {
+    for (const msg of data.messages) {
+      msg.timestamp = new Date(msg.timestamp);
+      if (!this.agentMessages.has(msg.agentName)) {
+        this.agentMessages.set(msg.agentName, []);
+      }
+      this.agentMessages.get(msg.agentName).push(msg);
+      this.allMessages.push(msg);
+    }
+    if (data.threads) {
+      for (const thread of data.threads) {
+        thread.created = new Date(thread.created);
+        thread.lastActivity = new Date(thread.lastActivity);
+        for (const msg of thread.messages) {
+          msg.timestamp = new Date(msg.timestamp);
+        }
+        this.threads.set(thread.id, thread);
+      }
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    const messagesByAgent = {};
+    const messagesByRole = {};
+    for (const msg of this.allMessages) {
+      messagesByAgent[msg.agentName] = (messagesByAgent[msg.agentName] ?? 0) + 1;
+      messagesByRole[msg.role] = (messagesByRole[msg.role] ?? 0) + 1;
+    }
+    const agentCount = Object.keys(messagesByAgent).length;
+    return {
+      totalMessages: this.allMessages.length,
+      messagesByAgent,
+      messagesByRole,
+      totalThreads: this.threads.size,
+      averageMessagesPerAgent: agentCount > 0 ? this.allMessages.length / agentCount : 0
+    };
+  }
+};
+function createConversationHistory(config) {
+  return new ConversationHistory(config);
+}
+
+// src/memory/KnowledgeBase.ts
+import { nanoid as nanoid5 } from "nanoid";
+var KnowledgeBase = class {
+  items = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  typeIndex = /* @__PURE__ */ new Map();
+  contributorIndex = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxItems: config.maxItems ?? 1e4,
+      autoIndex: config.autoIndex ?? true,
+      minConfidence: config.minConfidence ?? 0,
+      deduplicate: config.deduplicate ?? true
+    };
+  }
+  // ============ CRUD Operations ============
+  /**
+   * Add knowledge item
+   */
+  add(item) {
+    if (item.confidence < this.config.minConfidence) {
+      throw new Error(
+        `Confidence ${item.confidence} below threshold ${this.config.minConfidence}`
+      );
+    }
+    if (this.config.deduplicate) {
+      const duplicate = this.findDuplicate(item.title, item.content);
+      if (duplicate) {
+        return this.update(duplicate.id, {
+          ...item,
+          confidence: Math.max(duplicate.confidence, item.confidence)
+        });
+      }
+    }
+    if (this.items.size >= this.config.maxItems) {
+      this.evictLeastUsed();
+    }
+    const fullItem = {
+      ...item,
+      id: nanoid5(),
+      created: /* @__PURE__ */ new Date(),
+      updated: /* @__PURE__ */ new Date(),
+      accessCount: 0
+    };
+    this.items.set(fullItem.id, fullItem);
+    if (this.config.autoIndex) {
+      this.indexItem(fullItem);
+    }
+    return fullItem;
+  }
+  /**
+   * Get knowledge item
+   */
+  get(id) {
+    const item = this.items.get(id);
+    if (item) {
+      item.accessCount++;
+    }
+    return item;
+  }
+  /**
+   * Update knowledge item
+   */
+  update(id, updates) {
+    const item = this.items.get(id);
+    if (!item) {
+      throw new Error(`Knowledge item not found: ${id}`);
+    }
+    if (this.config.autoIndex) {
+      this.unindexItem(item);
+    }
+    const updatedItem = {
+      ...item,
+      ...updates,
+      updated: /* @__PURE__ */ new Date()
+    };
+    this.items.set(id, updatedItem);
+    if (this.config.autoIndex) {
+      this.indexItem(updatedItem);
+    }
+    return updatedItem;
+  }
+  /**
+   * Delete knowledge item
+   */
+  delete(id) {
+    const item = this.items.get(id);
+    if (!item) return false;
+    if (this.config.autoIndex) {
+      this.unindexItem(item);
+    }
+    return this.items.delete(id);
+  }
+  // ============ Search & Query ============
+  /**
+   * Search knowledge base
+   */
+  search(query, options = {}) {
+    let results = this.textSearch(query);
+    if (options.type) {
+      results = results.filter((item) => item.type === options.type);
+    }
+    if (options.tags && options.tags.length > 0) {
+      results = results.filter(
+        (item) => options.tags.some((tag) => item.tags.includes(tag))
+      );
+    }
+    if (options.contributor) {
+      results = results.filter(
+        (item) => item.contributor === options.contributor
+      );
+    }
+    if (options.minConfidence !== void 0) {
+      results = results.filter(
+        (item) => item.confidence >= options.minConfidence
+      );
+    }
+    results = this.sortResults(results, options.sortBy ?? "relevance", query);
+    if (options.limit) {
+      results = results.slice(0, options.limit);
+    }
+    for (const item of results) {
+      item.accessCount++;
+    }
+    return results;
+  }
+  /**
+   * Get by tag
+   */
+  getByTag(tag, limit) {
+    const ids = this.tagIndex.get(tag.toLowerCase());
+    if (!ids) return [];
+    let items = Array.from(ids).map((id) => this.items.get(id)).filter(Boolean);
+    if (limit) {
+      items = items.slice(0, limit);
+    }
+    return items;
+  }
+  /**
+   * Get by type
+   */
+  getByType(type, limit) {
+    const ids = this.typeIndex.get(type);
+    if (!ids) return [];
+    let items = Array.from(ids).map((id) => this.items.get(id)).filter(Boolean);
+    if (limit) {
+      items = items.slice(0, limit);
+    }
+    return items;
+  }
+  /**
+   * Get by contributor
+   */
+  getByContributor(contributor, limit) {
+    const ids = this.contributorIndex.get(contributor);
+    if (!ids) return [];
+    let items = Array.from(ids).map((id) => this.items.get(id)).filter(Boolean);
+    if (limit) {
+      items = items.slice(0, limit);
+    }
+    return items;
+  }
+  /**
+   * Get related items
+   */
+  getRelated(id, limit = 5) {
+    const item = this.items.get(id);
+    if (!item) return [];
+    const relatedIds = /* @__PURE__ */ new Set();
+    for (const tag of item.tags) {
+      const taggedIds = this.tagIndex.get(tag.toLowerCase());
+      if (taggedIds) {
+        for (const relatedId of taggedIds) {
+          if (relatedId !== id) {
+            relatedIds.add(relatedId);
+          }
+        }
+      }
+    }
+    const scored = Array.from(relatedIds).map((relatedId) => {
+      const relatedItem = this.items.get(relatedId);
+      const overlap = item.tags.filter(
+        (t) => relatedItem.tags.includes(t)
+      ).length;
+      return { item: relatedItem, score: overlap };
+    });
+    return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.item);
+  }
+  // ============ Agent Contributions ============
+  /**
+   * Contribute knowledge from an agent
+   */
+  contributeKnowledge(agentName, type, title, content, tags = [], confidence = 0.8) {
+    return this.add({
+      type,
+      title,
+      content,
+      tags,
+      contributor: agentName,
+      confidence
+    });
+  }
+  /**
+   * Add a fact
+   */
+  addFact(title, content, tags = [], source) {
+    return this.add({
+      type: "fact",
+      title,
+      content,
+      tags,
+      source,
+      confidence: 0.9
+    });
+  }
+  /**
+   * Add a procedure
+   */
+  addProcedure(title, steps, tags = []) {
+    return this.add({
+      type: "procedure",
+      title,
+      content: steps.map((s, i) => `${i + 1}. ${s}`).join("\n"),
+      tags,
+      confidence: 0.85
+    });
+  }
+  /**
+   * Add an insight
+   */
+  addInsight(title, content, contributor, tags = []) {
+    return this.add({
+      type: "insight",
+      title,
+      content,
+      tags,
+      contributor,
+      confidence: 0.7
+    });
+  }
+  /**
+   * Add a warning
+   */
+  addWarning(title, content, tags = []) {
+    return this.add({
+      type: "warning",
+      title,
+      content,
+      tags,
+      confidence: 0.95
+    });
+  }
+  // ============ Indexing ============
+  /**
+   * Index an item
+   */
+  indexItem(item) {
+    for (const tag of item.tags) {
+      const tagLower = tag.toLowerCase();
+      if (!this.tagIndex.has(tagLower)) {
+        this.tagIndex.set(tagLower, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tagLower).add(item.id);
+    }
+    if (!this.typeIndex.has(item.type)) {
+      this.typeIndex.set(item.type, /* @__PURE__ */ new Set());
+    }
+    this.typeIndex.get(item.type).add(item.id);
+    if (item.contributor) {
+      if (!this.contributorIndex.has(item.contributor)) {
+        this.contributorIndex.set(item.contributor, /* @__PURE__ */ new Set());
+      }
+      this.contributorIndex.get(item.contributor).add(item.id);
+    }
+  }
+  /**
+   * Remove item from indices
+   */
+  unindexItem(item) {
+    for (const tag of item.tags) {
+      const tagLower = tag.toLowerCase();
+      this.tagIndex.get(tagLower)?.delete(item.id);
+    }
+    this.typeIndex.get(item.type)?.delete(item.id);
+    if (item.contributor) {
+      this.contributorIndex.get(item.contributor)?.delete(item.id);
+    }
+  }
+  /**
+   * Text search
+   */
+  textSearch(query) {
+    const queryLower = query.toLowerCase();
+    const queryWords = queryLower.split(/\s+/);
+    const scored = [];
+    for (const item of this.items.values()) {
+      let score = 0;
+      const titleLower = item.title.toLowerCase();
+      const contentLower = item.content.toLowerCase();
+      if (titleLower.includes(queryLower)) {
+        score += 3;
+      }
+      if (contentLower.includes(queryLower)) {
+        score += 1;
+      }
+      for (const word of queryWords) {
+        if (titleLower.includes(word)) score += 0.5;
+        if (contentLower.includes(word)) score += 0.2;
+        if (item.tags.some((t) => t.toLowerCase().includes(word))) score += 0.3;
+      }
+      if (score > 0) {
+        scored.push({ item, score });
+      }
+    }
+    return scored.sort((a, b) => b.score - a.score).map((s) => s.item);
+  }
+  /**
+   * Sort results
+   */
+  sortResults(items, sortBy, _query) {
+    switch (sortBy) {
+      case "recency":
+        return items.sort((a, b) => b.updated.getTime() - a.updated.getTime());
+      case "confidence":
+        return items.sort((a, b) => b.confidence - a.confidence);
+      case "access":
+        return items.sort((a, b) => b.accessCount - a.accessCount);
+      case "relevance":
+      default:
+        return items;
+    }
+  }
+  /**
+   * Find duplicate
+   */
+  findDuplicate(title, content) {
+    const titleLower = title.toLowerCase();
+    const contentLower = content.toLowerCase().substring(0, 200);
+    for (const item of this.items.values()) {
+      if (item.title.toLowerCase() === titleLower || item.content.toLowerCase().substring(0, 200) === contentLower) {
+        return item;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Evict least used item
+   */
+  evictLeastUsed() {
+    let leastUsed;
+    let minAccess = Infinity;
+    for (const item of this.items.values()) {
+      if (item.accessCount < minAccess) {
+        minAccess = item.accessCount;
+        leastUsed = item;
+      }
+    }
+    if (leastUsed) {
+      this.delete(leastUsed.id);
+    }
+  }
+  // ============ Utilities ============
+  /**
+   * Get all tags
+   */
+  getTags() {
+    return Array.from(this.tagIndex.keys());
+  }
+  /**
+   * Get all types
+   */
+  getTypes() {
+    return Array.from(this.typeIndex.keys());
+  }
+  /**
+   * Get all contributors
+   */
+  getContributors() {
+    return Array.from(this.contributorIndex.keys());
+  }
+  /**
+   * Get all items
+   */
+  getAll() {
+    return Array.from(this.items.values());
+  }
+  /**
+   * Get count
+   */
+  getCount() {
+    return this.items.size;
+  }
+  /**
+   * Clear all
+   */
+  clear() {
+    this.items.clear();
+    this.tagIndex.clear();
+    this.typeIndex.clear();
+    this.contributorIndex.clear();
+  }
+  /**
+   * Export
+   */
+  export() {
+    return Array.from(this.items.values());
+  }
+  /**
+   * Import
+   */
+  import(items) {
+    let count = 0;
+    for (const item of items) {
+      item.created = new Date(item.created);
+      item.updated = new Date(item.updated);
+      this.items.set(item.id, item);
+      if (this.config.autoIndex) {
+        this.indexItem(item);
+      }
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    const itemsByType = {};
+    const itemsByContributor = {};
+    let totalConfidence = 0;
+    for (const item of this.items.values()) {
+      itemsByType[item.type] = (itemsByType[item.type] ?? 0) + 1;
+      if (item.contributor) {
+        itemsByContributor[item.contributor] = (itemsByContributor[item.contributor] ?? 0) + 1;
+      }
+      totalConfidence += item.confidence;
+    }
+    const mostUsedTags = Array.from(this.tagIndex.entries()).map(([tag, ids]) => ({ tag, count: ids.size })).sort((a, b) => b.count - a.count).slice(0, 10);
+    return {
+      totalItems: this.items.size,
+      itemsByType,
+      itemsByContributor,
+      totalTags: this.tagIndex.size,
+      averageConfidence: this.items.size > 0 ? totalConfidence / this.items.size : 0,
+      mostUsedTags
+    };
+  }
+};
+function createKnowledgeBase(config) {
+  return new KnowledgeBase(config);
+}
+export {
+  AgentCapabilities,
+  AgentRegistry,
+  AuctionStrategy,
+  BaseDelegationStrategy,
+  BestMatchStrategy,
+  BranchBuilder,
+  CheckpointManager,
+  CodeReviewTasks,
+  CollaborationManager,
+  ConflictResolver,
+  ConsensusStrategy,
+  ConversationHistory,
+  Crew,
+  CrewAgent,
+  CrewDashboard,
+  CustomerSupportTasks,
+  DAGExecutor,
+  DebugMode,
+  DelegationCoordinator,
+  DelegationError,
+  ExecutionContext,
+  HierarchicalStrategy,
+  InMemoryCheckpointStorage,
+  KnowledgeBase,
+  LoopBuilder,
+  PRIORITY_WEIGHTS,
+  PROFICIENCY_WEIGHTS,
+  ParallelExecutor,
+  ResearchTasks,
+  Role,
+  RoundRobinStrategy,
+  STRATEGY_TYPES,
+  SharedMemory,
+  Task,
+  TaskQueue,
+  WorkflowBuilder,
+  WritingTasks,
+  createAgentRegistry,
+  createAuctionStrategy,
+  createBestMatchStrategy,
+  createCheckpointManager,
+  createCodeReviewCrew,
+  createCodeReviewCrewConfig,
+  createCollaborationManager,
+  createConflictResolver,
+  createConsensusStrategy,
+  createConversationHistory,
+  createCrew,
+  createCrewAgent,
+  createCustomerSupportCrew,
+  createCustomerSupportCrewConfig,
+  createDAGExecutor,
+  createDAGFromSteps,
+  createDashboard,
+  createDebugMode,
+  createDelegationCoordinator,
+  createExecutionContext,
+  createHierarchicalStrategy,
+  createKnowledgeBase,
+  createParallelExecutor,
+  createResearchCrew,
+  createResearchCrewConfig,
+  createRole,
+  createRoundRobinStrategy,
+  createSharedMemory,
+  createStrategy,
+  createTask,
+  createTaskQueue,
+  createWritingCrew,
+  createWritingCrewConfig,
+  workflow
+};