anyclaude-sdk 0.10.2 → 0.11.0

package/README.md

@@ -224,6 +224,20 @@ const mailbox = await BroadcastChannelMailbox.crossTab({ channelName: 'team', or
 query({ prompt, workspace, llm, team: true, mailbox })
 ```
 
+**Push delivery to a running agent.** Messages addressed to an agent are
+auto-injected into its transcript at the next turn boundary — same model as the
+message queue, but from the shared mailbox. So a coordinator (or peer, or another
+worker) can redirect a **running** sub-agent mid-task and it lands on the
+sub-agent's next tool round, no polling tool needed. `dispatch_tasks` names each
+worker `worker:<taskId>` so you can target a specific one:
+
+```typescript
+mailbox.send('coordinator', 'worker:task_1', 'while you work: also add logging')
+// worker:task_1 sees "[Team messages] - from coordinator: ..." on its next step.
+```
+
+On by default with `team: true`; opt out via `query({ deliverTeamMessages: false })`.
+
 ## Pluggable backends
 
 You aren't tied to WebContainer. A `Sandbox` is just a `FileSystem` plus a

package/dist/agent.d.ts

@@ -119,6 +119,11 @@ export interface AgentOptions {
     board?: TaskBoard;
     /** This agent's name/label for messaging (default 'coordinator'). */
     agentName?: string;
+    /** Auto-deliver unread mailbox messages addressed to this agent into the
+     *  transcript at each turn boundary (push delivery, like the message queue).
+     *  Default true when `team` is enabled. Set false to require an explicit
+     *  pull instead. */
+    deliverTeamMessages?: boolean;
     /** Persist the transcript to this store (keyed by sessionId) for resume. */
     sessionStore?: SessionStoreLike;
     /** Load the stored transcript for sessionId before the first turn. */

package/dist/agent.js

@@ -212,6 +212,7 @@ export async function* runAgent(options) {
     const mailbox = teamEnabled ? options.mailbox ?? new Mailbox() : undefined;
     const board = teamEnabled ? options.board ?? new TaskBoard() : undefined;
     const agentName = options.agentName ?? 'coordinator';
+    const deliverTeamMessages = options.deliverTeamMessages ?? true;
     let localTools = subagentsEnabled && !baseTools.some((t) => t.def.function.name === 'task')
         ? [...baseTools, taskTool]
         : baseTools;
@@ -344,7 +345,7 @@ export async function* runAgent(options) {
     // Wire sub-agent spawning. Each call runs a fresh, isolated runAgent to
     // completion and returns only its final text.
     if (subagentsEnabled) {
-        ctx.runSubagent = async ({ prompt: subPrompt, agentType, signal: subSignal, onProgress }) => {
+        ctx.runSubagent = async ({ prompt: subPrompt, agentType, name: subName, signal: subSignal, onProgress }) => {
             const def = agentType ? agents?.[agentType] : undefined;
             const subSystem = def?.prompt ?? defaultSubagentPrompt(cwd);
             const subTools = def?.tools
@@ -389,7 +390,8 @@ export async function* runAgent(options) {
                 team: teamEnabled,
                 mailbox,
                 board,
-                agentName: agentType || 'worker',
+                deliverTeamMessages,
+                agentName: subName || agentType || 'worker',
                 memory,
                 skills,
             });
@@ -626,6 +628,29 @@ export async function* runAgent(options) {
                     };
                 }
             }
+            // Team mailbox: push unread messages addressed to THIS agent into the
+            // transcript at the turn boundary — same delivery model as the queue, but
+            // sourced from the shared mailbox. This lets a coordinator (or any peer)
+            // dispatch a message to a *running* sub-agent and have it land on the
+            // sub-agent's next tool round, no polling tool required. Cross-worker too:
+            // a BroadcastChannelMailbox replicates the message before it's drained.
+            if (mailbox && deliverTeamMessages) {
+                const unread = mailbox.inbox(agentName, { unreadOnly: true });
+                if (unread.length) {
+                    mailbox.markRead(agentName);
+                    const body = '[Team messages]\n' +
+                        unread.map((m) => `- from ${m.from}: ${m.text}`).join('\n');
+                    history.push({ role: 'user', content: body });
+                    yield {
+                        type: 'user',
+                        message: { role: 'user', content: body },
+                        parent_tool_use_id: null,
+                        timestamp: new Date().toISOString(),
+                        uuid: uuid(),
+                        session_id: sessionId,
+                    };
+                }
+            }
             // Auto-compaction: summarize when the transcript nears the context limit.
             // Circuit-breaker: stop after 3 compactions (avoids a summarize loop).
             if (options.autoCompact && autoCompactCount < 3 && history.length > 3) {

package/dist/query.d.ts

@@ -87,6 +87,10 @@ export interface QueryOptions {
     board?: import('./team/index.js').TaskBoard;
     /** This agent's name/label for messaging (default 'coordinator'). */
     agentName?: string;
+    /** Auto-deliver unread mailbox messages addressed to this agent into the
+     *  transcript at each turn boundary (push delivery, like the message queue).
+     *  Default true when `team` is enabled. */
+    deliverTeamMessages?: boolean;
     /** Persist the transcript to this store (keyed by sessionId) for resume. */
     sessionStore?: SessionStoreLike;
     /** Load the stored transcript for sessionId before the first turn. */

package/dist/query.js

@@ -49,6 +49,7 @@ export function query(options) {
         includePartialMessages: options.includePartialMessages,
         team: options.team,
         mailbox: options.mailbox,
+        deliverTeamMessages: options.deliverTeamMessages,
         board: options.board,
         agentName: options.agentName,
         sessionStore: options.sessionStore,

package/dist/team/dispatch.js

@@ -23,11 +23,20 @@ export const dispatchTasks = {
         if (!board || !runSubagent) {
             return { content: 'Teammates/sub-agents are not enabled for this session.', isError: true };
         }
-        const spawn = (task) => runSubagent({
-            description: task.subject,
-            prompt: `Complete this task:\n# ${task.subject}\n${task.description ?? ''}\n\n` +
-                'When done, your final message should report exactly what you did.',
-        });
+        const spawn = (task) => {
+            // Give each worker a unique, addressable name and reflect it as the task
+            // owner, so the coordinator can dispatch a message to this specific
+            // running worker (delivered on its next tool round via the mailbox).
+            const name = `worker:${task.id}`;
+            board.update(task.id, { owner: name });
+            return runSubagent({
+                description: task.subject,
+                name,
+                prompt: `You are teammate "${name}". Complete this task:\n# ${task.subject}\n${task.description ?? ''}\n\n` +
+                    'New instructions from the coordinator may arrive mid-task as `[Team messages]` — adapt when they do. ' +
+                    'When done, your final message should report exactly what you did.',
+            });
+        };
         const summary = await runTeamLoop(board, spawn, {
             concurrency: typeof input.concurrency === 'number' ? input.concurrency : undefined,
             signal: ctx.signal,

package/dist/team/prompt.js

@@ -6,7 +6,7 @@ You are the coordinator of a team of agents. Plan and delegate rather than doing
 
 - Decompose the work into discrete tasks on the shared board with \`task_create\`. When a task depends on another, set \`blocked_by\` to the prerequisite task ids so execution is correctly gated.
 - Spawn workers with the \`task\` tool to execute board tasks — give each worker a focused prompt and, when useful, run independent workers in parallel. Prefer parallelism over sequential work whenever tasks are independent.
-- Use \`send_message\` to direct workers, hand off context, or coordinate between teammates. Check the board with \`board_list\` and \`task_get\` to track progress, and keep task status current with \`task_update\` (mark in_progress when started, completed/failed when done).
+- Use \`send_message\` to direct workers, hand off context, or coordinate between teammates. Dispatched workers are named \`worker:<taskId>\` (shown as the task owner in \`board_list\`); a message addressed to that name is delivered to that worker on its next step, even while it is still running — use this to redirect or add context mid-task. Check the board with \`board_list\` and \`task_get\` to track progress, and keep task status current with \`task_update\` (mark in_progress when started, completed/failed when done).
 - Synthesize workers' results yourself before continuing. NEVER fabricate or assume a worker's output — rely only on what they actually returned.
 - Keep the board the source of truth: every meaningful unit of work should be a task with an owner and a status.`;
 }

package/dist/telemetry.d.ts

@@ -1,5 +1,5 @@
 /** Bump on release so adoption can be bucketed by version. */
-export declare const TELEMETRY_SDK_VERSION = "0.10.2";
+export declare const TELEMETRY_SDK_VERSION = "0.11.0";
 export interface TelemetryOptions {
     /** Force-disable for this call (highest precedence besides the global opt-outs). */
     disabled?: boolean;

package/dist/telemetry.js

@@ -16,7 +16,7 @@
 // See TELEMETRY.md for the full disclosure.
 import { uuid } from './util/ids.js';
 /** Bump on release so adoption can be bucketed by version. */
-export const TELEMETRY_SDK_VERSION = '0.10.2';
+export const TELEMETRY_SDK_VERSION = '0.11.0';
 // Aggregate-only collector (Puter Worker; see examples/telemetry-collector).
 // Override with `ANYCLAUDE_TELEMETRY_URL` / `telemetry: { url }`, or disable
 // entirely with the opt-outs above. Set to '' to make telemetry a no-op.

package/dist/tools/types.d.ts

@@ -33,6 +33,10 @@ export interface ToolContext {
         description: string;
         prompt: string;
         agentType?: string;
+        /** Unique name for this sub-agent in the shared mailbox, so peers can
+         *  address messages to this specific running worker. Defaults to the
+         *  agentType (or 'worker'). */
+        name?: string;
         /** Abort signal (e.g. a background task's stop) — cancels the sub-agent. */
         signal?: AbortSignal;
         /** Streamed progress (assistant text + tool names) as the sub-agent works. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Standalone, browser-compatible SDK providing Claude Code agent capabilities (tools, tool loop, multi-turn, MCP, sub-agents, sessions) against any OpenAI/Anthropic-compatible LLM endpoint. Runs in the browser (WebContainer), Node, and Bun — no backend required.",
   "type": "module",
   "main": "./dist/index.js",