fix(core): report broadcast delivery failures in send_message

packages/core/src/agents/team/TeamManager.ts

@@ -88,6 +88,14 @@ const debug = createDebugLogger('AGENTS_TEAM_MANAGER');
 // imported it from this module keep compiling.
 export type { TeamAgentHandle };
 
+/** Delivery outcome of a {@link TeamManager.broadcast} call. */
+export interface BroadcastResult {
+  /** Number of recipients the broadcast attempted (sender excluded). */
+  total: number;
+  /** Names of recipients whose delivery was rejected. */
+  failedRecipients: string[];
+}
+
 /** Configuration for spawning a teammate. */
 export interface TeammateSpawnConfig {
   /** Human-readable name (will be sanitized). */
@@ -670,31 +678,38 @@ export class TeamManager {
   /**
    * Broadcast a message to all teammates and the leader
    * (except the sender).
+   *
+   * Returns the delivery outcome so the caller can distinguish complete
+   * success from partial/total failure instead of assuming every
+   * delivery landed.
    */
-  async broadcast(message: string, fromName: string): Promise<void> {
-    const promises = this.teamFile.members
+  async broadcast(message: string, fromName: string): Promise<BroadcastResult> {
+    const recipients = this.teamFile.members
       .filter((m) => m.name.toLowerCase() !== fromName.toLowerCase())
-      .map((m) => this.sendMessage(m.name, message, fromName));
+      .map((m) => m.name);
 
     // Also deliver to leader inbox if sender is not the leader.
     if (fromName.toLowerCase() !== LEADER_NAME) {
-      promises.push(this.sendMessage(LEADER_NAME, message, fromName));
+      recipients.push(LEADER_NAME);
     }
 
     // allSettled, not all: a single recipient that terminated between
     // the member snapshot and the send throws (its queue is gone), and
     // Promise.all would reject the whole broadcast — making the leader
     // think every recipient failed when the rest were delivered fine.
-    const results = await Promise.allSettled(promises);
-    const failures = results.filter(
-      (r): r is PromiseRejectedResult => r.status === 'rejected',
+    const results = await Promise.allSettled(
+      recipients.map((name) => this.sendMessage(name, message, fromName)),
+    );
+    const failedRecipients = recipients.filter(
+      (_, i) => results[i]?.status === 'rejected',
     );
-    if (failures.length > 0) {
+    if (failedRecipients.length > 0) {
       debug.warn(
-        `Broadcast: ${failures.length}/${results.length} send(s) failed ` +
+        `Broadcast: ${failedRecipients.length}/${results.length} send(s) failed ` +
           `(recipient likely terminated).`,
       );
     }
+    return { total: recipients.length, failedRecipients };
   }
 
   /**

packages/core/src/agents/team/test-utils/coordination-harness.test.ts

@@ -2049,6 +2049,33 @@ describe('TeamCoordinationHarness', () => {
       expect(w3.getReceivedMessages()).toHaveLength(1);
       expectTeamMessage(w3.getReceivedMessages()[0], 'w2', 'hello all');
     });
+
+    it('reports zero failures when every delivery lands (#10072)', async () => {
+      const h = await createHarness();
+      await h.spawnTeammate('w1');
+      await h.spawnTeammate('w2');
+
+      // Recipients: w2 (member) + leader inbox.
+      const result = await h.teamManager.broadcast('hello all', 'w1');
+
+      expect(result).toEqual({ total: 2, failedRecipients: [] });
+      await h.waitForMessages('w2', 1);
+    });
+
+    it('reports the recipients whose delivery was rejected (#10072)', async () => {
+      const h = await createHarness();
+      await h.spawnTeammate('w1');
+      const w2 = await h.spawnTeammate('w2');
+
+      // w2 terminates between the member snapshot and the send: its
+      // queue is dropped, so its delivery rejects while the leader
+      // inbox write still lands.
+      await w2.shutdown();
+
+      const result = await h.teamManager.broadcast('status update', 'w1');
+
+      expect(result).toEqual({ total: 2, failedRecipients: ['w2'] });
+    });
   });
 
   // ─── 6. Concurrent task claiming ──────────────────────────

packages/core/src/tools/send-message.broadcast.test.ts

@@ -0,0 +1,130 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Broadcast delivery-outcome contract for send_message(to: "*") — #10072.
+ *
+ * Uses the real TeamManager (via TeamCoordinationHarness) so a delivery
+ * rejects the same way it does in production: a recipient terminates
+ * between the member snapshot and the send, its per-agent queue is
+ * dropped, and sendMessage refuses the delivery.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { SendMessageTool } from './send-message.js';
+import { BackgroundTaskRegistry } from '../agents/background-tasks.js';
+import type { ApprovalMode, Config } from '../config/config.js';
+import type { TeamManager } from '../agents/team/TeamManager.js';
+import { TeamCoordinationHarness } from '../agents/team/test-utils/coordination-harness.js';
+
+// Mock Storage so all file I/O uses the harness's temp dir.
+vi.mock('../config/storage.js', async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import('../config/storage.js')>();
+  let mockGlobalDir = '';
+  return {
+    ...original,
+    Storage: {
+      ...original.Storage,
+      getGlobalQwenDir: () => mockGlobalDir,
+      __setMockGlobalDir: (dir: string) => {
+        mockGlobalDir = dir;
+      },
+    },
+  };
+});
+
+import { Storage } from '../config/storage.js';
+
+function setMockDir(dir: string): void {
+  (
+    Storage as unknown as {
+      __setMockGlobalDir: (d: string) => void;
+    }
+  ).__setMockGlobalDir(dir);
+}
+
+function makeConfig(teamManager: TeamManager): Config {
+  return {
+    getTeamManager: () => teamManager,
+    getBackgroundTaskRegistry: () => new BackgroundTaskRegistry(),
+    getApprovalMode: () => 'default' as ApprovalMode,
+  } as unknown as Config;
+}
+
+describe('SendMessageTool — broadcast delivery outcomes (#10072)', () => {
+  let harness: TeamCoordinationHarness | undefined;
+
+  afterEach(async () => {
+    await harness?.cleanup();
+    harness = undefined;
+  });
+
+  async function createHarness(): Promise<TeamCoordinationHarness> {
+    const h = await TeamCoordinationHarness.create();
+    setMockDir(h.tmpDir);
+    harness = h;
+    return h;
+  }
+
+  function broadcastInvocation(h: TeamCoordinationHarness) {
+    const tool = new SendMessageTool(makeConfig(h.teamManager));
+    return tool.build({ to: '*', message: 'sync for everyone' });
+  }
+
+  it('does not claim complete success when a delivery is rejected', async () => {
+    const h = await createHarness();
+    await h.spawnTeammate('alice');
+    const bob = await h.spawnTeammate('bob');
+
+    // bob terminates between the member snapshot and the send: its
+    // queue is dropped, so its delivery rejects while alice's lands.
+    await bob.shutdown();
+
+    const result = await broadcastInvocation(h).execute(
+      new AbortController().signal,
+    );
+
+    expect(result.error).toBeUndefined();
+    // Must not claim that every teammate received the message…
+    expect(result.llmContent).not.toBe('Message broadcast to all teammates.');
+    // …and must name the recipient that was not reached.
+    expect(String(result.llmContent)).toContain('bob');
+  });
+
+  it('still reports complete success when every delivery lands', async () => {
+    const h = await createHarness();
+    const alice = await h.spawnTeammate('alice');
+    await h.spawnTeammate('bob');
+
+    const result = await broadcastInvocation(h).execute(
+      new AbortController().signal,
+    );
+
+    expect(result.error).toBeUndefined();
+    expect(result.llmContent).toBe('Message broadcast to all teammates.');
+    await h.waitForMessages('alice', 1);
+    await h.waitForMessages('bob', 1);
+    expect(alice.getReceivedMessages()).toHaveLength(1);
+  });
+
+  it('reports failure when no delivery lands', async () => {
+    const h = await createHarness();
+    const alice = await h.spawnTeammate('alice');
+    const bob = await h.spawnTeammate('bob');
+    await alice.shutdown();
+    await bob.shutdown();
+
+    const result = await broadcastInvocation(h).execute(
+      new AbortController().signal,
+    );
+
+    expect(result.error).toBeDefined();
+    expect(result.llmContent).not.toBe('Message broadcast to all teammates.');
+    expect(String(result.llmContent)).toContain('alice');
+    expect(String(result.llmContent)).toContain('bob');
+  });
+});

packages/core/src/tools/send-message.test.ts

@@ -10,14 +10,15 @@ import { BackgroundTaskRegistry } from '../agents/background-tasks.js';
 import { ToolErrorType } from './tool-error.js';
 import type { ApprovalMode, Config } from '../config/config.js';
 import { runWithTeammateIdentity } from '../agents/team/identity.js';
+import type { BroadcastResult } from '../agents/team/TeamManager.js';
 
 const DEFAULT_MODE = 'default' as ApprovalMode;
 const PLAN_MODE = 'plan' as ApprovalMode;
 
 function makeTeamConfig(opts?: {
   teamManager?: {
     sendMessage: (...args: unknown[]) => Promise<void>;
-    broadcast: (...args: unknown[]) => Promise<void>;
+    broadcast: (...args: unknown[]) => Promise<BroadcastResult>;
   } | null;
   approvalMode?: ApprovalMode;
 }) {
@@ -69,7 +70,9 @@ describe('SendMessageTool — team mode', () => {
   });
 
   it('broadcasts with "*"', async () => {
-    const broadcast = vi.fn().mockResolvedValue(undefined);
+    const broadcast = vi
+      .fn()
+      .mockResolvedValue({ total: 2, failedRecipients: [] });
     const tool = new SendMessageTool(
       makeTeamConfig({
         teamManager: {

packages/core/src/tools/send-message.ts

@@ -242,8 +242,29 @@ class SendMessageInvocation extends BaseToolInvocation<
     try {
       if (to === '*') {
         const sender = getAgentName() ?? LEADER_NAME;
-        await teamManager.broadcast(this.params.message, sender);
-        const msg = 'Message broadcast to all teammates.';
+        const { total, failedRecipients } = await teamManager.broadcast(
+          this.params.message,
+          sender,
+        );
+        if (failedRecipients.length === 0) {
+          const msg = 'Message broadcast to all teammates.';
+          return { llmContent: msg, returnDisplay: msg };
+        }
+        const reached = total - failedRecipients.length;
+        if (reached === 0) {
+          const msg =
+            `Broadcast failed: delivery was rejected for all ${total} ` +
+            `recipient(s): ${failedRecipients.join(', ')}.`;
+          return {
+            llmContent: msg,
+            returnDisplay: msg,
+            error: { message: msg },
+          };
+        }
+        const msg =
+          `Message broadcast delivered to ${reached} of ${total} ` +
+          `recipient(s); delivery failed for: ${failedRecipients.join(', ')}. ` +
+          `The listed recipients did not receive the message.`;
         return { llmContent: msg, returnDisplay: msg };
       }