@lov3kaizen/agentsea-crews 1.1.0 → 1.1.1

package/dist/DebugMode-CbYgA7Yw.d.mts

@@ -0,0 +1,190 @@
+import { EventEmitter } from 'eventemitter3';
+import { C as CrewStatusDetails, a as Crew, b as CrewEvent, c as CrewMetrics, T as TimelineEntry, d as TaskConfig } from './Crew-BnvVjN7A.mjs';
+
+interface AgentStatus {
+    name: string;
+    role: string;
+    status: 'idle' | 'busy' | 'error';
+    currentTask?: string;
+    tasksCompleted: number;
+    tasksFailed: number;
+    tokensUsed: number;
+    lastActivity?: Date;
+}
+interface DashboardUpdate {
+    type: 'status_change' | 'agent_update' | 'task_update' | 'metrics_update' | 'event';
+    timestamp: Date;
+    data: unknown;
+}
+interface DashboardConfig {
+    updateInterval?: number;
+    trackEvents?: boolean;
+    maxEvents?: number;
+}
+declare class CrewDashboard extends EventEmitter<{
+    update: (update: DashboardUpdate) => void;
+    statusChange: (status: CrewStatusDetails) => void;
+    agentUpdate: (agent: AgentStatus) => void;
+    error: (error: Error) => void;
+}> {
+    private readonly crew;
+    private readonly config;
+    private readonly events;
+    private updateTimer?;
+    private lastStatus?;
+    private subscribed;
+    constructor(crew: Crew, config?: DashboardConfig);
+    start(): void;
+    stop(): void;
+    subscribe(callback: (update: DashboardUpdate) => void): () => void;
+    recordEvent(event: CrewEvent): void;
+    getCrewStatus(): CrewStatusDetails;
+    getAgentStatuses(): Map<string, AgentStatus>;
+    getMetrics(): CrewMetrics;
+    getTimeline(): TimelineEntry[];
+    getEvents(filter?: {
+        type?: string;
+        agent?: string;
+        since?: Date;
+        limit?: number;
+    }): CrewEvent[];
+    getProgress(): {
+        percentage: number;
+        completedTasks: number;
+        totalTasks: number;
+        currentTask?: string;
+        elapsedTime: number;
+        estimatedRemaining?: number;
+    };
+    getTaskBreakdown(): {
+        pending: number;
+        inProgress: number;
+        completed: number;
+        failed: number;
+        total: number;
+    };
+    getAgentBreakdown(): {
+        total: number;
+        busy: number;
+        idle: number;
+        performance: Array<{
+            name: string;
+            completed: number;
+            failed: number;
+            successRate: number;
+        }>;
+    };
+    private emitUpdate;
+    getSnapshot(): DashboardSnapshot;
+}
+interface DashboardSnapshot {
+    timestamp: Date;
+    status: CrewStatusDetails;
+    metrics: CrewMetrics;
+    agents: Record<string, AgentStatus>;
+    progress: ReturnType<CrewDashboard['getProgress']>;
+    taskBreakdown: ReturnType<CrewDashboard['getTaskBreakdown']>;
+    agentBreakdown: ReturnType<CrewDashboard['getAgentBreakdown']>;
+    recentEvents: CrewEvent[];
+}
+declare function createDashboard(crew: Crew, config?: DashboardConfig): CrewDashboard;
+
+type BreakpointType = 'task:assigned' | 'task:started' | 'task:completed' | 'task:failed' | 'agent:thinking' | 'delegation:decision' | 'custom';
+interface Breakpoint {
+    id: string;
+    type: BreakpointType;
+    condition?: (event: CrewEvent, context: DebugContext) => boolean;
+    enabled: boolean;
+    hitCount: number;
+}
+interface DebugContext {
+    currentEvent?: CrewEvent;
+    agents: Map<string, AgentInspection>;
+    tasks: TaskConfig[];
+    variables: Map<string, unknown>;
+    callStack: string[];
+}
+interface AgentInspection {
+    name: string;
+    role: string;
+    status: 'idle' | 'busy' | 'paused';
+    currentTask?: string;
+    lastThought?: string;
+    lastToolCall?: {
+        tool: string;
+        input: unknown;
+        output?: unknown;
+    };
+    memory: Map<string, unknown>;
+}
+interface StepResult {
+    event: CrewEvent;
+    breakpointHit?: Breakpoint;
+    agentStates: Map<string, AgentInspection>;
+    continueExecution: boolean;
+}
+interface DebugModeConfig {
+    pauseOnError?: boolean;
+    verbose?: boolean;
+    maxCallStackDepth?: number;
+}
+declare class DebugMode extends EventEmitter<{
+    breakpointHit: (breakpoint: Breakpoint, event: CrewEvent) => void;
+    step: (result: StepResult) => void;
+    error: (error: Error) => void;
+    paused: () => void;
+    resumed: () => void;
+}> {
+    private readonly crew;
+    private readonly config;
+    private readonly breakpoints;
+    private readonly eventQueue;
+    private readonly callStack;
+    private context;
+    private enabled;
+    private paused;
+    private stepMode;
+    private breakpointCounter;
+    private resolveStep?;
+    constructor(crew: Crew, config?: DebugModeConfig);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setBreakpoint(type: BreakpointType, condition?: (event: CrewEvent, context: DebugContext) => boolean): string;
+    removeBreakpoint(id: string): boolean;
+    enableBreakpoint(id: string): boolean;
+    disableBreakpoint(id: string): boolean;
+    getBreakpoints(): Breakpoint[];
+    clearBreakpoints(): void;
+    step(): Promise<StepResult>;
+    continue(): Promise<void>;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    inspect(agentName: string): AgentInspection | undefined;
+    inspectAll(): Map<string, AgentInspection>;
+    getContext(): DebugContext;
+    getCallStack(): string[];
+    evaluate(expression: string): unknown;
+    watch(expression: string): {
+        expression: string;
+        value: unknown;
+    };
+    handleEvent(event: CrewEvent): void;
+    private createContext;
+    private updateContext;
+    private checkBreakpoints;
+    private getAgentStates;
+    private createAgentInspection;
+    getSummary(): {
+        enabled: boolean;
+        paused: boolean;
+        stepMode: boolean;
+        breakpointCount: number;
+        queuedEvents: number;
+        callStackDepth: number;
+    };
+}
+declare function createDebugMode(crew: Crew, config?: DebugModeConfig): DebugMode;
+
+export { type AgentInspection as A, type Breakpoint as B, CrewDashboard as C, DebugMode as D, type StepResult as S, type AgentStatus as a, type BreakpointType as b, type DashboardConfig as c, type DashboardSnapshot as d, type DashboardUpdate as e, type DebugContext as f, type DebugModeConfig as g, createDashboard as h, createDebugMode as i };

package/dist/DebugMode-o5e9gmQ7.d.ts

@@ -0,0 +1,190 @@
+import { EventEmitter } from 'eventemitter3';
+import { C as CrewStatusDetails, a as Crew, b as CrewEvent, c as CrewMetrics, T as TimelineEntry, d as TaskConfig } from './Crew-BnvVjN7A.js';
+
+interface AgentStatus {
+    name: string;
+    role: string;
+    status: 'idle' | 'busy' | 'error';
+    currentTask?: string;
+    tasksCompleted: number;
+    tasksFailed: number;
+    tokensUsed: number;
+    lastActivity?: Date;
+}
+interface DashboardUpdate {
+    type: 'status_change' | 'agent_update' | 'task_update' | 'metrics_update' | 'event';
+    timestamp: Date;
+    data: unknown;
+}
+interface DashboardConfig {
+    updateInterval?: number;
+    trackEvents?: boolean;
+    maxEvents?: number;
+}
+declare class CrewDashboard extends EventEmitter<{
+    update: (update: DashboardUpdate) => void;
+    statusChange: (status: CrewStatusDetails) => void;
+    agentUpdate: (agent: AgentStatus) => void;
+    error: (error: Error) => void;
+}> {
+    private readonly crew;
+    private readonly config;
+    private readonly events;
+    private updateTimer?;
+    private lastStatus?;
+    private subscribed;
+    constructor(crew: Crew, config?: DashboardConfig);
+    start(): void;
+    stop(): void;
+    subscribe(callback: (update: DashboardUpdate) => void): () => void;
+    recordEvent(event: CrewEvent): void;
+    getCrewStatus(): CrewStatusDetails;
+    getAgentStatuses(): Map<string, AgentStatus>;
+    getMetrics(): CrewMetrics;
+    getTimeline(): TimelineEntry[];
+    getEvents(filter?: {
+        type?: string;
+        agent?: string;
+        since?: Date;
+        limit?: number;
+    }): CrewEvent[];
+    getProgress(): {
+        percentage: number;
+        completedTasks: number;
+        totalTasks: number;
+        currentTask?: string;
+        elapsedTime: number;
+        estimatedRemaining?: number;
+    };
+    getTaskBreakdown(): {
+        pending: number;
+        inProgress: number;
+        completed: number;
+        failed: number;
+        total: number;
+    };
+    getAgentBreakdown(): {
+        total: number;
+        busy: number;
+        idle: number;
+        performance: Array<{
+            name: string;
+            completed: number;
+            failed: number;
+            successRate: number;
+        }>;
+    };
+    private emitUpdate;
+    getSnapshot(): DashboardSnapshot;
+}
+interface DashboardSnapshot {
+    timestamp: Date;
+    status: CrewStatusDetails;
+    metrics: CrewMetrics;
+    agents: Record<string, AgentStatus>;
+    progress: ReturnType<CrewDashboard['getProgress']>;
+    taskBreakdown: ReturnType<CrewDashboard['getTaskBreakdown']>;
+    agentBreakdown: ReturnType<CrewDashboard['getAgentBreakdown']>;
+    recentEvents: CrewEvent[];
+}
+declare function createDashboard(crew: Crew, config?: DashboardConfig): CrewDashboard;
+
+type BreakpointType = 'task:assigned' | 'task:started' | 'task:completed' | 'task:failed' | 'agent:thinking' | 'delegation:decision' | 'custom';
+interface Breakpoint {
+    id: string;
+    type: BreakpointType;
+    condition?: (event: CrewEvent, context: DebugContext) => boolean;
+    enabled: boolean;
+    hitCount: number;
+}
+interface DebugContext {
+    currentEvent?: CrewEvent;
+    agents: Map<string, AgentInspection>;
+    tasks: TaskConfig[];
+    variables: Map<string, unknown>;
+    callStack: string[];
+}
+interface AgentInspection {
+    name: string;
+    role: string;
+    status: 'idle' | 'busy' | 'paused';
+    currentTask?: string;
+    lastThought?: string;
+    lastToolCall?: {
+        tool: string;
+        input: unknown;
+        output?: unknown;
+    };
+    memory: Map<string, unknown>;
+}
+interface StepResult {
+    event: CrewEvent;
+    breakpointHit?: Breakpoint;
+    agentStates: Map<string, AgentInspection>;
+    continueExecution: boolean;
+}
+interface DebugModeConfig {
+    pauseOnError?: boolean;
+    verbose?: boolean;
+    maxCallStackDepth?: number;
+}
+declare class DebugMode extends EventEmitter<{
+    breakpointHit: (breakpoint: Breakpoint, event: CrewEvent) => void;
+    step: (result: StepResult) => void;
+    error: (error: Error) => void;
+    paused: () => void;
+    resumed: () => void;
+}> {
+    private readonly crew;
+    private readonly config;
+    private readonly breakpoints;
+    private readonly eventQueue;
+    private readonly callStack;
+    private context;
+    private enabled;
+    private paused;
+    private stepMode;
+    private breakpointCounter;
+    private resolveStep?;
+    constructor(crew: Crew, config?: DebugModeConfig);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setBreakpoint(type: BreakpointType, condition?: (event: CrewEvent, context: DebugContext) => boolean): string;
+    removeBreakpoint(id: string): boolean;
+    enableBreakpoint(id: string): boolean;
+    disableBreakpoint(id: string): boolean;
+    getBreakpoints(): Breakpoint[];
+    clearBreakpoints(): void;
+    step(): Promise<StepResult>;
+    continue(): Promise<void>;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    inspect(agentName: string): AgentInspection | undefined;
+    inspectAll(): Map<string, AgentInspection>;
+    getContext(): DebugContext;
+    getCallStack(): string[];
+    evaluate(expression: string): unknown;
+    watch(expression: string): {
+        expression: string;
+        value: unknown;
+    };
+    handleEvent(event: CrewEvent): void;
+    private createContext;
+    private updateContext;
+    private checkBreakpoints;
+    private getAgentStates;
+    private createAgentInspection;
+    getSummary(): {
+        enabled: boolean;
+        paused: boolean;
+        stepMode: boolean;
+        breakpointCount: number;
+        queuedEvents: number;
+        callStackDepth: number;
+    };
+}
+declare function createDebugMode(crew: Crew, config?: DebugModeConfig): DebugMode;
+
+export { type AgentInspection as A, type Breakpoint as B, CrewDashboard as C, DebugMode as D, type StepResult as S, type AgentStatus as a, type BreakpointType as b, type DashboardConfig as c, type DashboardSnapshot as d, type DashboardUpdate as e, type DebugContext as f, type DebugModeConfig as g, createDashboard as h, createDebugMode as i };

package/dist/{chunk-6JLVFEU6.mjs → chunk-3NMVWRVW.mjs}

@@ -1,6 +1,6 @@
 import {
   createCrew
-} from "./chunk-V6VK6BOL.mjs";
+} from "./chunk-J5KQSOGT.mjs";
 
 // src/templates/ResearchCrew.ts
 var researcherRole = {

package/dist/{chunk-V6VK6BOL.mjs → chunk-J5KQSOGT.mjs}

@@ -211,8 +211,37 @@ function createRole(config) {
   return new Role(config);
 }
 
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "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);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.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
-import { nanoid } from "nanoid";
 var Task = class _Task {
   id;
   description;
@@ -844,7 +873,6 @@ function createTaskQueue(config) {
 
 // src/core/ExecutionContext.ts
 import EventEmitter from "eventemitter3";
-import { nanoid as nanoid2 } from "nanoid";
 var ExecutionContext = class {
   crewId;
   crewName;
@@ -861,7 +889,7 @@ var ExecutionContext = class {
   startTime;
   endTime;
   constructor(config) {
-    this.crewId = config.crewId ?? nanoid2();
+    this.crewId = config.crewId ?? nanoid();
     this.crewName = config.crewName;
     this.state = /* @__PURE__ */ new Map();
     this.completedTasks = /* @__PURE__ */ new Map();
@@ -1107,7 +1135,7 @@ var ExecutionContext = class {
    */
   createCheckpoint() {
     return {
-      id: nanoid2(),
+      id: nanoid(),
       timestamp: /* @__PURE__ */ new Date(),
       crewId: this.crewId,
       crewName: this.crewName,
@@ -1450,7 +1478,6 @@ function createCoreExecutor(config, options = {}) {
 }
 
 // src/agents/CrewAgent.ts
-import { nanoid as nanoid3 } from "nanoid";
 function modelCostWeight(model) {
   const m = (model ?? "").toLowerCase();
   if (m.includes("opus") || m.includes("gpt-5") || m.includes("o3")) return 5;
@@ -1481,7 +1508,7 @@ var CrewAgent = class _CrewAgent {
   totalTokensUsed = 0;
   constructor(options) {
     const { config, execute } = options;
-    this.id = nanoid3();
+    this.id = nanoid();
     this.name = config.name;
     this.role = new Role(config.role);
     this.capabilities = config.role.capabilities;
@@ -1678,7 +1705,7 @@ ${JSON.stringify(task.context, null, 2)}`);
    */
   createHelpRequest(taskId, request) {
     return {
-      requestId: nanoid3(),
+      requestId: nanoid(),
       fromAgent: this.name,
       taskId,
       request
@@ -4131,7 +4158,6 @@ function createConflictResolver(config) {
 }
 
 // src/core/Crew.ts
-import { nanoid as nanoid4 } from "nanoid";
 var Crew = class {
   id;
   name;
@@ -4151,7 +4177,7 @@ var Crew = class {
   timeline = [];
   results = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.id = nanoid4();
+    this.id = nanoid();
     this.name = config.name;
     this.description = config.description;
     this.config = config;
@@ -4300,27 +4326,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);
@@ -4363,6 +4402,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
    */
@@ -4582,7 +4693,7 @@ ${r.output}`).join("\n\n---\n\n");
    */
   createCheckpoint() {
     return {
-      id: nanoid4(),
+      id: nanoid(),
       crewId: this.id,
       crewName: this.name,
       timestamp: /* @__PURE__ */ new Date(),
@@ -4680,6 +4791,7 @@ function createCrew(config) {
 export {
   Role,
   createRole,
+  nanoid,
   Task,
   createTask,
   TaskQueue,