@wrongstack/core 0.3.2 → 0.3.4

package/dist/{config-D2qvAxVd.d.ts → config-DgE3JslD.d.ts}

@@ -130,6 +130,7 @@ interface MCPServerConfig {
     allowedTools?: string[];
     permission?: Permission;
     startupTimeoutMs?: number;
+    requestTimeoutMs?: number;
 }
 interface LogConfig {
     level: 'error' | 'warn' | 'info' | 'debug' | 'trace';

package/dist/coordination/index.d.ts

@@ -5,12 +5,12 @@ import { I as InMemoryAgentBridge } from '../agent-bridge-C3DUGjSb.js';
 export { a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-C3DUGjSb.js';
 import { E as EventBus } from '../events-BHIQs4o1.js';
 import { EventEmitter } from 'node:events';
-import { r as Agent, u as AgentInput } from '../index-hWNybrNZ.js';
+import { r as Agent, u as AgentInput } from '../index-DedY4Euf.js';
 import '../logger-BMQgxvdy.js';
 import '../system-prompt-Dk1qm8ey.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-CgG2tV2B.js';
-import '../config-D2qvAxVd.js';
+import '../config-DgE3JslD.js';
 import '../models-registry-Y2xbog0E.js';
 
 /**
@@ -590,7 +590,9 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
     completeTask(result: TaskResult): void;
     private tryDispatchNext;
     private canDispatch;
+    private takeNextDispatchableTask;
     private findIdleSubagent;
+    private isIdleSubagent;
     /**
      * Returns true iff at least one spawned subagent could still
      * process a task. A "live" subagent is one that is not stopped

package/dist/coordination/index.js

@@ -893,8 +893,8 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   // --- internal dispatching ---------------------------------------------
   tryDispatchNext() {
     while (this.canDispatch()) {
-      const subagentId = this.findIdleSubagent();
-      if (!subagentId) {
+      const dispatchable = this.takeNextDispatchableTask();
+      if (!dispatchable) {
         if (this.pendingTasks.length > 0 && !this.hasLiveSubagent()) {
           this.drainPendingAsAborted(
             "No live subagent available \u2014 all stopped or mid-termination"
@@ -902,8 +902,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
         }
         return;
       }
-      const task = this.pendingTasks.shift();
-      if (!task) return;
+      const { subagentId, task } = dispatchable;
       this.runDispatched(subagentId, task).catch((err) => {
         this.recordCompletion({
           subagentId,
@@ -921,12 +920,26 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     const max = this.config.maxConcurrent ?? 4;
     return this.inFlight < max && this.pendingTasks.length > 0;
   }
+  takeNextDispatchableTask() {
+    for (let i = 0; i < this.pendingTasks.length; i++) {
+      const task = this.pendingTasks[i];
+      const subagentId = task.subagentId ? this.isIdleSubagent(task.subagentId) ? task.subagentId : null : this.findIdleSubagent();
+      if (!subagentId) continue;
+      this.pendingTasks.splice(i, 1);
+      return { subagentId, task };
+    }
+    return null;
+  }
   findIdleSubagent() {
     for (const [id, s] of this.subagents) {
       if (s.status === "idle" && !this.terminating.has(id)) return id;
     }
     return null;
   }
+  isIdleSubagent(id) {
+    const subagent = this.subagents.get(id);
+    return !!subagent && subagent.status === "idle" && !this.terminating.has(id);
+  }
   /**
    * Returns true iff at least one spawned subagent could still
    * process a task. A "live" subagent is one that is not stopped
@@ -1111,10 +1124,11 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
 };
 function classifySubagentError(err, hints = {}) {
   const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
-  const baseMessage = err instanceof Error ? err.message : String(err);
   if (err instanceof ProviderError) {
-    return providerErrorToSubagentError(err, baseMessage, cause);
+    const baseMessage2 = err.describe();
+    return providerErrorToSubagentError(err, baseMessage2, cause);
   }
+  const baseMessage = err instanceof Error ? err.message : String(err);
   if (err instanceof BudgetExceededError) {
     const map = {
       iterations: "budget_iterations",
@@ -1231,7 +1245,7 @@ function makeSpawnTool(director, roster) {
       if (role && !base) {
         return { error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}` };
       }
-      const cfg = { ...base ?? { name: i.name ?? "subagent" } };
+      const cfg = base ? instantiateRosterConfig(role, base) : { name: i.name ?? "subagent" };
       if (typeof i.name === "string") cfg.name = i.name;
       if (typeof i.provider === "string") cfg.provider = i.provider;
       if (typeof i.model === "string") cfg.model = i.model;
@@ -1251,6 +1265,14 @@ function makeSpawnTool(director, roster) {
     }
   };
 }
+function instantiateRosterConfig(role, base) {
+  return {
+    ...base,
+    // Roster entries are templates. A director may spawn several
+    // workers with the same role, so never reuse the template id.
+    id: `${role}-${randomUUID().slice(0, 8)}`
+  };
+}
 function makeAssignTool(director) {
   const inputSchema = {
     type: "object",
@@ -2012,7 +2034,7 @@ function createDelegateTool(opts) {
             error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
           };
         }
-        cfg = { ...base };
+        cfg = instantiateRosterConfig2(i.role, base);
         if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
         if (i.provider) cfg.provider = i.provider;
         if (i.model) cfg.model = i.model;
@@ -2098,6 +2120,14 @@ function createDelegateTool(opts) {
     }
   };
 }
+function instantiateRosterConfig2(role, base) {
+  return {
+    ...base,
+    // Roster entries are templates. Give each spawn a fresh id so
+    // parallel or repeated delegates can use the same role safely.
+    id: `${role}-${randomUUID().slice(0, 8)}`
+  };
+}
 function hintForKind(kind, retryable, backoffMs) {
   if (!kind) return void 0;
   switch (kind) {