@lov3kaizen/agentsea-crews 1.0.1 → 1.1.1

package/dist/index.js

@@ -77,6 +77,7 @@ __export(index_exports, {
   createConflictResolver: () => createConflictResolver,
   createConsensusStrategy: () => createConsensusStrategy,
   createConversationHistory: () => createConversationHistory,
+  createCoreExecutor: () => createCoreExecutor,
   createCrew: () => createCrew,
   createCrewAgent: () => createCrewAgent,
   createCustomerSupportCrew: () => createCustomerSupportCrew,
@@ -333,8 +334,37 @@ function createRole(config) {
   return new Role(config);
 }
 
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var import_node_crypto = require("crypto");
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
 // src/core/Task.ts
-var import_nanoid = require("nanoid");
 var Task = class _Task {
   id;
   description;
@@ -354,7 +384,7 @@ var Task = class _Task {
   _result;
   _metadata;
   constructor(config) {
-    this.id = config.id ?? (0, import_nanoid.nanoid)();
+    this.id = config.id ?? nanoid();
     this.description = config.description;
     this.expectedOutput = config.expectedOutput;
     this.priority = config.priority ?? "medium";
@@ -966,7 +996,6 @@ function createTaskQueue(config) {
 
 // src/core/ExecutionContext.ts
 var import_eventemitter3 = __toESM(require("eventemitter3"));
-var import_nanoid2 = require("nanoid");
 var ExecutionContext = class {
   crewId;
   crewName;
@@ -983,7 +1012,7 @@ var ExecutionContext = class {
   startTime;
   endTime;
   constructor(config) {
-    this.crewId = config.crewId ?? (0, import_nanoid2.nanoid)();
+    this.crewId = config.crewId ?? nanoid();
     this.crewName = config.crewName;
     this.state = /* @__PURE__ */ new Map();
     this.completedTasks = /* @__PURE__ */ new Map();
@@ -1229,7 +1258,7 @@ var ExecutionContext = class {
    */
   createCheckpoint() {
     return {
-      id: (0, import_nanoid2.nanoid)(),
+      id: nanoid(),
       timestamp: /* @__PURE__ */ new Date(),
       crewId: this.crewId,
       crewName: this.crewName,
@@ -1318,12 +1347,6 @@ function createExecutionContext(config) {
   return new ExecutionContext(config);
 }
 
-// src/core/Crew.ts
-var import_nanoid4 = require("nanoid");
-
-// src/agents/CrewAgent.ts
-var import_nanoid3 = require("nanoid");
-
 // src/agents/AgentCapabilities.ts
 var PROFICIENCY_WEIGHTS2 = {
   novice: 0.25,
@@ -1515,7 +1538,80 @@ var AgentCapabilities = class {
   }
 };
 
+// src/agents/CoreExecutor.ts
+async function loadProvider(providerName) {
+  const ctorName = resolveProviderCtorName(providerName);
+  let core;
+  try {
+    core = await import("@lov3kaizen/agentsea-core");
+  } catch {
+    throw new Error(
+      'CrewAgent requires "@lov3kaizen/agentsea-core" to execute against a real LLM. Install it, or pass a custom `execute` function (or `mock: true`) to createCrewAgent / createCrew.'
+    );
+  }
+  const Ctor = core[ctorName];
+  return new Ctor();
+}
+function resolveProviderCtorName(providerName) {
+  switch ((providerName ?? "").toLowerCase()) {
+    case "anthropic":
+    case "claude":
+      return "AnthropicProvider";
+    case "openai":
+    case "gpt":
+      return "OpenAIProvider";
+    case "gemini":
+    case "google":
+      return "GeminiProvider";
+    case "ollama":
+      return "OllamaProvider";
+    default:
+      throw new Error(
+        `CrewAgent: unsupported provider "${providerName}". Supported providers are: anthropic, openai, gemini, ollama. Pass a custom \`execute\` function to createCrewAgent for any other provider.`
+      );
+  }
+}
+function createCoreExecutor(config, options = {}) {
+  let providerPromise;
+  const getProvider = () => {
+    if (!providerPromise) {
+      providerPromise = options.provider ? Promise.resolve(options.provider) : loadProvider(config.provider);
+    }
+    return providerPromise;
+  };
+  return async (input, systemPrompt) => {
+    const provider = await getProvider();
+    const start = Date.now();
+    const response = await provider.generateResponse(
+      [{ role: "user", content: input }],
+      {
+        model: config.model,
+        systemPrompt,
+        temperature: config.temperature,
+        maxTokens: config.maxTokens
+      }
+    );
+    return {
+      output: response.content,
+      tokensUsed: response.usage.inputTokens + response.usage.outputTokens,
+      latencyMs: Date.now() - start,
+      iterations: 1
+    };
+  };
+}
+
 // src/agents/CrewAgent.ts
+function modelCostWeight(model) {
+  const m = (model ?? "").toLowerCase();
+  if (m.includes("opus") || m.includes("gpt-5") || m.includes("o3")) return 5;
+  if (m.includes("sonnet") || m.includes("gpt-4.1") || m.includes("gpt-4") && !m.includes("mini") || m.includes("gemini-1.5-pro") || m.includes("gemini-2.5-pro")) {
+    return 3;
+  }
+  if (m.includes("haiku") || m.includes("mini") || m.includes("flash") || m.includes("llama") || m.includes("mistral")) {
+    return 1;
+  }
+  return 3;
+}
 var CrewAgent = class _CrewAgent {
   id;
   name;
@@ -1535,7 +1631,7 @@ var CrewAgent = class _CrewAgent {
   totalTokensUsed = 0;
   constructor(options) {
     const { config, execute } = options;
-    this.id = (0, import_nanoid3.nanoid)();
+    this.id = nanoid();
     this.name = config.name;
     this.role = new Role(config.role);
     this.capabilities = config.role.capabilities;
@@ -1554,10 +1650,11 @@ var CrewAgent = class _CrewAgent {
    */
   async execute(input) {
     if (!this.executeFunc) {
+      const tokensUsed = 100 + Math.min(input.length, 400);
       const mockResult = {
         output: `[Mock response from ${this.name}]: ${input.slice(0, 100)}...`,
-        tokensUsed: Math.floor(Math.random() * 500) + 100,
-        latencyMs: Math.floor(Math.random() * 2e3) + 500,
+        tokensUsed,
+        latencyMs: 0,
         iterations: 1
       };
       this.totalTokensUsed += mockResult.tokensUsed;
@@ -1660,16 +1757,27 @@ ${JSON.stringify(task.context, null, 2)}`);
       ) ?? true
     ).map((c) => c.name);
     const estimatedTime = this.estimateTaskTime(task);
+    const estimatedCost = this.estimateTaskCost(estimatedTime);
     const reasoning = this.generateBidReasoning(task, confidence, matchedCaps);
     return Promise.resolve({
       agentName: this.name,
       taskId: task.id ?? "unknown",
       confidence,
       estimatedTime,
+      estimatedCost,
       reasoning,
       capabilities: matchedCaps
     });
   }
+  /**
+   * Estimate a relative cost for handling a task. Combines the agent's model
+   * price tier with the estimated effort so the auction `cheapest` criterion
+   * can distinguish a cheap-but-slower model from an expensive-but-faster one.
+   * The unit is arbitrary and only meaningful relative to other bids.
+   */
+  estimateTaskCost(estimatedTime) {
+    return modelCostWeight(this.model) * Math.max(estimatedTime, 1);
+  }
   /**
    * Check if agent has all required capabilities
    */
@@ -1720,7 +1828,7 @@ ${JSON.stringify(task.context, null, 2)}`);
    */
   createHelpRequest(taskId, request) {
     return {
-      requestId: (0, import_nanoid3.nanoid)(),
+      requestId: nanoid(),
       fromAgent: this.name,
       taskId,
       request
@@ -1855,7 +1963,13 @@ Please provide helpful guidance based on your expertise.
   }
 };
 function createCrewAgent(options) {
-  return new CrewAgent(options);
+  if (options.execute || options.mock) {
+    return new CrewAgent(options);
+  }
+  return new CrewAgent({
+    ...options,
+    execute: createCoreExecutor(options.config, { provider: options.provider })
+  });
 }
 
 // src/agents/AgentRegistry.ts
@@ -2564,9 +2678,9 @@ var AuctionStrategy = class extends BaseDelegationStrategy {
         }, bids[0]);
       case "cheapest":
         return bids.reduce((best, bid) => {
-          const bestTime = best.estimatedTime ?? Infinity;
-          const bidTime = bid.estimatedTime ?? Infinity;
-          return bidTime < bestTime ? bid : best;
+          const bestCost = best.estimatedCost ?? best.estimatedTime ?? Infinity;
+          const bidCost = bid.estimatedCost ?? bid.estimatedTime ?? Infinity;
+          return bidCost < bestCost ? bid : best;
         }, bids[0]);
       case "confidence":
       default:
@@ -3055,9 +3169,8 @@ var ConsensusStrategy = class extends BaseDelegationStrategy {
    */
   async collectVotes(task, voters, candidates) {
     const votes = [];
-    const candidateNames = candidates.map((c) => c.name);
     for (const voter of voters) {
-      const vote = await this.getVote(voter, task, candidateNames);
+      const vote = await this.getVote(voter, task, candidates);
       if (vote) {
         votes.push(vote);
       }
@@ -3065,33 +3178,35 @@ var ConsensusStrategy = class extends BaseDelegationStrategy {
     return votes;
   }
   /**
-   * Get a vote from an agent
+   * Get a vote from an agent.
+   *
+   * Each voter ranks the candidates by how well their capabilities fit the
+   * task (the same `calculateTaskScore` signal the BestMatch/Auction strategies
+   * use), plus a small self-preference bias so an agent leans toward itself when
+   * candidates are otherwise comparable. This is fully deterministic — given the
+   * same agents and task it always produces the same votes — and explainable,
+   * which is what consensus needs. (A future enhancement could replace this with
+   * an actual LLM deliberation per voter; the tally/agreement logic is unchanged.)
    */
   getVote(voter, task, candidates) {
-    const scores = [];
-    for (const candidateName of candidates) {
-      if (candidateName === voter.name) {
-        scores.push({ name: candidateName, score: 0.7 });
-      } else {
-        const randomFactor = 0.8 + Math.random() * 0.4;
-        scores.push({
-          name: candidateName,
-          score: Math.random() * randomFactor
-        });
-      }
-    }
-    scores.sort((a, b) => b.score - a.score);
+    if (candidates.length === 0) return Promise.resolve(null);
+    const SELF_PREFERENCE_BONUS = 0.15;
+    const scores = candidates.map((candidate) => {
+      let score = candidate.calculateTaskScore(task);
+      if (candidate.name === voter.name) {
+        score += SELF_PREFERENCE_BONUS;
+      }
+      return { name: candidate.name, score };
+    });
+    scores.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
     const selected = scores[0];
     if (!selected) return Promise.resolve(null);
-    let weight = 1;
-    if (this.weightedVoting) {
-      weight = voter.calculateTaskScore(task) || 0.5;
-    }
+    const weight = this.weightedVoting ? voter.calculateTaskScore(task) || 0.5 : 1;
     return Promise.resolve({
       voter: voter.name,
       candidate: selected.name,
       weight,
-      reasoning: `Selected based on perceived suitability (score: ${selected.score.toFixed(2)})`
+      reasoning: `Ranked "${selected.name}" highest by capability fit for the task (score: ${selected.score.toFixed(2)})`
     });
   }
   /**
@@ -3964,13 +4079,24 @@ var ConflictResolver = class {
       resolved: /* @__PURE__ */ new Date()
     };
   }
+  /**
+   * Normalize response content for equality comparison: trim, collapse runs of
+   * whitespace, and lowercase. This groups textually-equivalent answers (ignoring
+   * incidental formatting) over their FULL content rather than a fragile first-N
+   * characters prefix. Note: this is exact-match-after-normalization, not semantic
+   * similarity — agents that express the same idea with different wording will not
+   * group. Semantic grouping would require embeddings (future enhancement).
+   */
+  normalizeContent(content) {
+    return content.trim().replace(/\s+/g, " ").toLowerCase();
+  }
   /**
    * Resolve by voting
    */
   resolveByVoting(conflict, _context) {
     const votes = /* @__PURE__ */ new Map();
     for (const response of conflict.responses) {
-      const key = response.content.substring(0, 100);
+      const key = this.normalizeContent(response.content);
       const current = votes.get(key) ?? 0;
       votes.set(key, current + response.confidence);
     }
@@ -3983,7 +4109,7 @@ var ConflictResolver = class {
       }
     }
     const winner = conflict.responses.find(
-      (r) => r.content.substring(0, 100) === winningKey
+      (r) => this.normalizeContent(r.content) === winningKey
     );
     return Promise.resolve({
       conflictId: conflict.id,
@@ -3999,7 +4125,31 @@ var ConflictResolver = class {
    * Resolve by authority
    */
   resolveByAuthority(conflict, _context) {
-    return Promise.resolve(this.resolveByConfidence(conflict));
+    const ranked = conflict.responses.map((r) => ({
+      response: r,
+      authority: typeof r.metadata?.authority === "number" ? r.metadata.authority : void 0
+    })).filter(
+      (x) => x.authority !== void 0
+    );
+    if (ranked.length === 0) {
+      return Promise.resolve({
+        ...this.resolveByConfidence(conflict),
+        strategy: "authority",
+        explanation: "No authority metadata provided; fell back to highest confidence"
+      });
+    }
+    const winnerEntry = ranked.reduce(
+      (best, cur) => cur.authority > best.authority ? cur : best
+    );
+    return Promise.resolve({
+      conflictId: conflict.id,
+      strategy: "authority",
+      winner: winnerEntry.response,
+      explanation: `Selected response from highest-authority agent "${winnerEntry.response.agentName}" (authority: ${winnerEntry.authority})`,
+      successful: true,
+      escalated: false,
+      resolved: /* @__PURE__ */ new Date()
+    });
   }
   /**
    * Resolve by consensus
@@ -4007,7 +4157,7 @@ var ConflictResolver = class {
   resolveByConsensus(conflict, _context) {
     const contentGroups = /* @__PURE__ */ new Map();
     for (const response of conflict.responses) {
-      const key = response.content.substring(0, 100);
+      const key = this.normalizeContent(response.content);
       const group = contentGroups.get(key) ?? [];
       group.push(response);
       contentGroups.set(key, group);
@@ -4150,7 +4300,7 @@ var Crew = class {
   timeline = [];
   results = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.id = (0, import_nanoid4.nanoid)();
+    this.id = nanoid();
     this.name = config.name;
     this.description = config.description;
     this.config = config;
@@ -4170,7 +4320,12 @@ var Crew = class {
    */
   initializeAgents() {
     for (const agentConfig of this.config.agents) {
-      const agent = createCrewAgent({ config: agentConfig });
+      const agent = createCrewAgent({
+        config: agentConfig,
+        execute: this.config.execute,
+        mock: this.config.mock,
+        provider: this.config.provider
+      });
       this.addAgent(agent);
     }
   }
@@ -4294,27 +4449,40 @@ var Crew = class {
           await this.sleep(100);
           continue;
         }
-        for (const task of readyTasks) {
-          if (this.state !== "running") break;
-          const delegationResult = await this.delegateTask(task, options);
-          yield this.createEvent({
-            type: "task:assigned",
-            taskId: task.id,
-            agentName: delegationResult.selectedAgent,
-            reason: delegationResult.reason,
-            strategy: this.config.delegationStrategy
-          });
-          const taskResult = await this.executeTask(task, delegationResult);
-          yield this.createEvent({
-            type: "task:completed",
-            taskId: task.id,
-            result: taskResult,
-            agentName: delegationResult.selectedAgent,
-            durationMs: taskResult.latencyMs ?? 0
-          });
-          while (eventQueue.length > 0) {
-            yield eventQueue.shift();
+        const concurrency = Math.max(
+          1,
+          options.maxConcurrentTasks ?? this.config.maxConcurrentTasks ?? 1
+        );
+        if (concurrency === 1) {
+          for (const task of readyTasks) {
+            if (this.state !== "running") break;
+            const delegationResult = await this.delegateTask(task, options);
+            yield this.createEvent({
+              type: "task:assigned",
+              taskId: task.id,
+              agentName: delegationResult.selectedAgent,
+              reason: delegationResult.reason,
+              strategy: this.config.delegationStrategy
+            });
+            const taskResult = await this.executeTask(task, delegationResult);
+            yield this.createEvent({
+              type: "task:completed",
+              taskId: task.id,
+              result: taskResult,
+              agentName: delegationResult.selectedAgent,
+              durationMs: taskResult.latencyMs ?? 0
+            });
+            while (eventQueue.length > 0) {
+              yield eventQueue.shift();
+            }
           }
+        } else {
+          yield* this.processReadyTasksConcurrently(
+            readyTasks,
+            options,
+            eventQueue,
+            concurrency
+          );
         }
         while (this.state === "paused") {
           await this.sleep(100);
@@ -4357,6 +4525,78 @@ var Crew = class {
     });
     this.addTimelineEntry("crew_completed", this.name);
   }
+  /**
+   * Execute a batch of ready tasks concurrently with a bounded worker pool.
+   *
+   * Each task still emits its `task:assigned` and `task:completed` events in
+   * order relative to itself, but events across tasks are interleaved as the
+   * workers settle. At most `concurrency` tasks run at once. If any task throws
+   * (after exhausting retries), no further tasks are started, in-flight tasks
+   * are allowed to settle, and the first error is rethrown so the caller's
+   * error handling (crew:error) behaves identically to the sequential path.
+   */
+  async *processReadyTasksConcurrently(readyTasks, options, eventQueue, concurrency) {
+    let nextIndex = 0;
+    let firstError;
+    const buffer = [];
+    const inFlight = /* @__PURE__ */ new Set();
+    const launch = (task) => {
+      const worker = (async () => {
+        const delegationResult = await this.delegateTask(task, options);
+        buffer.push(
+          this.createEvent({
+            type: "task:assigned",
+            taskId: task.id,
+            agentName: delegationResult.selectedAgent,
+            reason: delegationResult.reason,
+            strategy: this.config.delegationStrategy
+          })
+        );
+        const taskResult = await this.executeTask(task, delegationResult);
+        buffer.push(
+          this.createEvent({
+            type: "task:completed",
+            taskId: task.id,
+            result: taskResult,
+            agentName: delegationResult.selectedAgent,
+            durationMs: taskResult.latencyMs ?? 0
+          })
+        );
+      })().catch((error) => {
+        if (firstError === void 0) {
+          firstError = error;
+        }
+      }).finally(() => {
+        inFlight.delete(worker);
+      });
+      inFlight.add(worker);
+    };
+    const fill = () => {
+      while (inFlight.size < concurrency && nextIndex < readyTasks.length && this.state === "running" && firstError === void 0) {
+        launch(readyTasks[nextIndex++]);
+      }
+    };
+    fill();
+    while (inFlight.size > 0) {
+      await Promise.race(inFlight);
+      while (buffer.length > 0) {
+        yield buffer.shift();
+      }
+      while (eventQueue.length > 0) {
+        yield eventQueue.shift();
+      }
+      fill();
+    }
+    while (buffer.length > 0) {
+      yield buffer.shift();
+    }
+    while (eventQueue.length > 0) {
+      yield eventQueue.shift();
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
   /**
    * Delegate a task to an agent
    */
@@ -4576,7 +4816,7 @@ ${r.output}`).join("\n\n---\n\n");
    */
   createCheckpoint() {
     return {
-      id: (0, import_nanoid4.nanoid)(),
+      id: nanoid(),
       crewId: this.id,
       crewName: this.name,
       timestamp: /* @__PURE__ */ new Date(),
@@ -4672,7 +4912,6 @@ function createCrew(config) {
 }
 
 // src/workflows/WorkflowBuilder.ts
-var import_nanoid5 = require("nanoid");
 var BranchBuilder = class {
   parent;
   condition;
@@ -4686,7 +4925,7 @@ var BranchBuilder = class {
    * Add steps for true branch
    */
   then(builder) {
-    const subBuilder = new WorkflowBuilder(`then-${(0, import_nanoid5.nanoid)(6)}`);
+    const subBuilder = new WorkflowBuilder(`then-${nanoid(6)}`);
     builder(subBuilder);
     this.thenSteps = subBuilder.getSteps();
     return this;
@@ -4695,7 +4934,7 @@ var BranchBuilder = class {
    * Add steps for false branch
    */
   otherwise(builder) {
-    const subBuilder = new WorkflowBuilder(`else-${(0, import_nanoid5.nanoid)(6)}`);
+    const subBuilder = new WorkflowBuilder(`else-${nanoid(6)}`);
     builder(subBuilder);
     this.elseSteps = subBuilder.getSteps();
     return this;
@@ -4705,7 +4944,7 @@ var BranchBuilder = class {
    */
   endBranch() {
     const conditionalConfig = {
-      name: `conditional-${(0, import_nanoid5.nanoid)(6)}`,
+      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
@@ -4731,7 +4970,7 @@ var LoopBuilder = class {
    * Set loop body
    */
   do(builder) {
-    const subBuilder = new WorkflowBuilder(`loop-body-${(0, import_nanoid5.nanoid)(6)}`);
+    const subBuilder = new WorkflowBuilder(`loop-body-${nanoid(6)}`);
     builder(subBuilder);
     this.bodySteps = subBuilder.getSteps();
     return this;
@@ -4748,7 +4987,7 @@ var LoopBuilder = class {
    */
   endLoop() {
     const loopConfig = {
-      name: `loop-${(0, import_nanoid5.nanoid)(6)}`,
+      name: `loop-${nanoid(6)}`,
       condition: this.condition,
       maxIterations: this.maxIter,
       bodySteps: this.bodySteps.map((s) => s.config)
@@ -4796,7 +5035,7 @@ var WorkflowBuilder = class {
    */
   parallel(...steps) {
     const parallelConfig = {
-      name: `parallel-${(0, import_nanoid5.nanoid)(6)}`,
+      name: `parallel-${nanoid(6)}`,
       steps: steps.map((s) => ({
         name: s.name,
         type: "task"
@@ -4947,7 +5186,7 @@ var WorkflowBuilder = class {
    */
   build() {
     return {
-      id: (0, import_nanoid5.nanoid)(),
+      id: nanoid(),
       name: this.name,
       description: this.description,
       steps: this.steps.map((s) => s.config),
@@ -4996,7 +5235,6 @@ function workflow(name) {
 }
 
 // src/workflows/DAGExecutor.ts
-var import_nanoid6 = require("nanoid");
 var DAGExecutor = class {
   dag;
   _handlers;
@@ -5427,24 +5665,27 @@ var DAGExecutor = class {
   }
 };
 function createDAGFromSteps(steps, _handlers) {
-  const nodes = [];
-  const previousNodeIds = [];
+  const nodeIds = steps.map(() => nanoid());
+  const nameToId = /* @__PURE__ */ new Map();
   for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    const nodeId = (0, import_nanoid6.nanoid)();
-    const node = {
-      id: nodeId,
+    nameToId.set(steps[i].name, nodeIds[i]);
+  }
+  const nodes = steps.map((step, i) => {
+    let dependencies;
+    if (step.dependsOn && step.dependsOn.length > 0) {
+      dependencies = step.dependsOn.map((name) => nameToId.get(name)).filter((id) => id !== void 0);
+    } else {
+      dependencies = i > 0 ? [nodeIds[i - 1]] : [];
+    }
+    return {
+      id: nodeIds[i],
       name: step.name,
       stepConfig: step,
-      dependencies: [...previousNodeIds]
-      // Sequential by default
+      dependencies
     };
-    nodes.push(node);
-    previousNodeIds.length = 0;
-    previousNodeIds.push(nodeId);
-  }
+  });
   return {
-    id: (0, import_nanoid6.nanoid)(),
+    id: nanoid(),
     nodes,
     edges: []
   };
@@ -5658,7 +5899,6 @@ function createParallelExecutor(options) {
 }
 
 // src/workflows/Checkpointing.ts
-var import_nanoid7 = require("nanoid");
 var InMemoryCheckpointStorage = class {
   checkpoints = /* @__PURE__ */ new Map();
   save(checkpoint) {
@@ -5712,7 +5952,7 @@ var CheckpointManager = class {
    */
   async save(workflowId, state) {
     const checkpoint = {
-      id: (0, import_nanoid7.nanoid)(),
+      id: nanoid(),
       workflowId,
       timestamp: /* @__PURE__ */ new Date(),
       stepIndex: state.currentStepIndex,
@@ -6237,7 +6477,6 @@ function createSharedMemory(config) {
 }
 
 // src/memory/ConversationHistory.ts
-var import_nanoid8 = require("nanoid");
 var ConversationHistory = class {
   agentMessages = /* @__PURE__ */ new Map();
   threads = /* @__PURE__ */ new Map();
@@ -6259,7 +6498,7 @@ var ConversationHistory = class {
   addMessage(agentName, message) {
     const fullMessage = {
       ...message,
-      id: (0, import_nanoid8.nanoid)(),
+      id: nanoid(),
       agentName,
       timestamp: /* @__PURE__ */ new Date(),
       threadId: this.currentThreadId
@@ -6406,7 +6645,7 @@ var ConversationHistory = class {
    */
   createThread(title, participants = []) {
     const thread = {
-      id: (0, import_nanoid8.nanoid)(),
+      id: nanoid(),
       title,
       participants,
       messages: [],
@@ -6601,7 +6840,6 @@ function createConversationHistory(config) {
 }
 
 // src/memory/KnowledgeBase.ts
-var import_nanoid9 = require("nanoid");
 var KnowledgeBase = class {
   items = /* @__PURE__ */ new Map();
   tagIndex = /* @__PURE__ */ new Map();
@@ -6640,7 +6878,7 @@ var KnowledgeBase = class {
     }
     const fullItem = {
       ...item,
-      id: (0, import_nanoid9.nanoid)(),
+      id: nanoid(),
       created: /* @__PURE__ */ new Date(),
       updated: /* @__PURE__ */ new Date(),
       accessCount: 0
@@ -8734,6 +8972,7 @@ Resolution: ${resolution}`,
   createConflictResolver,
   createConsensusStrategy,
   createConversationHistory,
+  createCoreExecutor,
   createCrew,
   createCrewAgent,
   createCustomerSupportCrew,