@lov3kaizen/agentsea-crews 1.0.1 → 1.1.0

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,
@@ -1515,7 +1516,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;
@@ -1554,10 +1628,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 +1735,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
    */
@@ -1855,7 +1941,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 +2656,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 +3147,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 +3156,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 +4057,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 +4087,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 +4103,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 +4135,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);
@@ -4170,7 +4298,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);
     }
   }
@@ -5427,22 +5560,25 @@ var DAGExecutor = class {
   }
 };
 function createDAGFromSteps(steps, _handlers) {
-  const nodes = [];
-  const previousNodeIds = [];
+  const nodeIds = steps.map(() => (0, import_nanoid6.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)(),
     nodes,
@@ -8734,6 +8870,7 @@ Resolution: ${resolution}`,
   createConflictResolver,
   createConsensusStrategy,
   createConversationHistory,
+  createCoreExecutor,
   createCrew,
   createCrewAgent,
   createCustomerSupportCrew,

package/dist/index.mjs

@@ -1,9 +1,3 @@
-import {
-  CrewDashboard,
-  DebugMode,
-  createDashboard,
-  createDebugMode
-} from "./chunk-4PF73ECN.mjs";
 import {
   CodeReviewTasks,
   CustomerSupportTasks,
@@ -17,7 +11,13 @@ import {
   createResearchCrewConfig,
   createWritingCrew,
   createWritingCrewConfig
-} from "./chunk-TFB7N65B.mjs";
+} from "./chunk-6JLVFEU6.mjs";
+import {
+  CrewDashboard,
+  DebugMode,
+  createDashboard,
+  createDebugMode
+} from "./chunk-4PF73ECN.mjs";
 import {
   AgentCapabilities,
   AgentRegistry,
@@ -44,6 +44,7 @@ import {
   createCollaborationManager,
   createConflictResolver,
   createConsensusStrategy,
+  createCoreExecutor,
   createCrew,
   createCrewAgent,
   createDelegationCoordinator,
@@ -54,7 +55,7 @@ import {
   createStrategy,
   createTask,
   createTaskQueue
-} from "./chunk-QMK3HWFX.mjs";
+} from "./chunk-V6VK6BOL.mjs";
 
 // src/types/role.types.ts
 var PROFICIENCY_WEIGHTS = {
@@ -828,22 +829,25 @@ var DAGExecutor = class {
   }
 };
 function createDAGFromSteps(steps, _handlers) {
-  const nodes = [];
-  const previousNodeIds = [];
+  const nodeIds = steps.map(() => nanoid2());
+  const nameToId = /* @__PURE__ */ new Map();
   for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    const nodeId = nanoid2();
-    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: nanoid2(),
     nodes,
@@ -2501,6 +2505,7 @@ export {
   createConflictResolver,
   createConsensusStrategy,
   createConversationHistory,
+  createCoreExecutor,
   createCrew,
   createCrewAgent,
   createCustomerSupportCrew,