anyclaude-sdk 0.9.0 → 0.10.0

package/README.md

@@ -198,6 +198,26 @@ Optional off-main-thread execution via a Comlink worker harness
 query({ prompt, workspace, llm, agents: {}, background: true })
 ```
 
+### Agents in separate Web Workers
+
+Two halves: **Comlink** for main→worker control (`wrapWorker` / `exposeBackgroundWorker`,
+above), and **`BroadcastChannelMailbox`** so agents in *different* workers gossip
+mailbox-style. It's a drop-in `Mailbox`, so the existing `team` tools
+(`send_message` / `dispatch_tasks`) work unchanged across workers:
+
+```typescript
+import { BroadcastChannelMailbox } from 'anyclaude-sdk'
+
+// inside each Web Worker / tab / worker_thread, same channel name:
+const mailbox = new BroadcastChannelMailbox({ channelName: 'team', origin: 'planner' })
+query({ prompt, workspace, llm, team: true, mailbox })
+// messages sent by one worker land in the addressed agent's inbox in another.
+```
+
+Uses the global `BroadcastChannel` by default; pass `{ channel }` (e.g. the
+[`broadcast-channel`](https://www.npmjs.com/package/broadcast-channel) package)
+for cross-tab durability or older runtimes.
+
 ## Pluggable backends
 
 You aren't tied to WebContainer. A `Sandbox` is just a `FileSystem` plus a

package/dist/team/broadcast-mailbox.d.ts

@@ -0,0 +1,34 @@
+import { Mailbox } from './mailbox.js';
+/** Minimal structural type for a BroadcastChannel-like transport, so callers
+ *  can inject the `broadcast-channel` polyfill or any compatible object. */
+export interface ChannelLike {
+    postMessage(data: unknown): void;
+    /** Native BroadcastChannel uses an `onmessage` setter with `{data}` events. */
+    onmessage?: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    /** `broadcast-channel` polyfill uses addEventListener('message', fn). */
+    addEventListener?: (type: 'message', fn: (data: unknown) => void) => void;
+    close?: () => void;
+}
+export interface BroadcastChannelMailboxOptions {
+    /** Channel name (default 'anyclaude-team'). Ignored if `channel` is given. */
+    channelName?: string;
+    /** Inject a ready-made channel (e.g. the `broadcast-channel` package) or a
+     *  custom BroadcastChannel factory. When omitted, the global BroadcastChannel
+     *  is used. */
+    channel?: ChannelLike;
+    /** Stable origin id for this instance; defaults to a random id. Set it to a
+     *  worker/agent name if you want deterministic, debuggable message ids. */
+    origin?: string;
+}
+export declare class BroadcastChannelMailbox extends Mailbox {
+    private readonly channel;
+    private readonly origin;
+    private closed;
+    constructor(opts?: BroadcastChannelMailboxOptions);
+    /** Send a message: append to the local replica and broadcast to peers. */
+    send(from: string, to: string, text: string): string;
+    /** Stop listening and release the channel. Safe to call more than once. */
+    close(): void;
+}

package/dist/team/broadcast-mailbox.js

@@ -0,0 +1,85 @@
+// A Mailbox that gossips across execution contexts (Web Workers, browser tabs,
+// Node worker_threads) over a BroadcastChannel. Drop-in for the in-memory
+// Mailbox: the existing `team` tools (send_message / dispatch_tasks) work
+// unchanged, but messages now propagate to every agent on the same channel.
+//
+// Design: each instance keeps its own eventually-consistent replica of the
+// message stream. `send()` appends locally AND posts on the channel; every
+// other instance ingests the inbound message into its replica (de-duped by a
+// globally-unique id). `inbox()`/`all()`/`markRead()` read/mutate the local
+// replica synchronously — read state is per-instance (each agent tracks what
+// *it* has seen), which is exactly the inbox semantics we want.
+//
+// Browser-safe: BroadcastChannel is a Web API (also a Node >=15 global inside
+// worker_threads). For older runtimes or cross-tab durability, inject the
+// `broadcast-channel` npm package's channel via the `channel` option.
+import { Mailbox } from './mailbox.js';
+function isWire(d) {
+    return !!d && typeof d === 'object' && d.__ac === 'msg';
+}
+function randomId() {
+    const g = globalThis;
+    if (g.crypto?.randomUUID)
+        return g.crypto.randomUUID().slice(0, 8);
+    // Fallback without Math.random reliance: derive from high-res-ish counters.
+    return 'o' + (Date.now().toString(36) + (originSeed++).toString(36));
+}
+let originSeed = 0;
+export class BroadcastChannelMailbox extends Mailbox {
+    constructor(opts = {}) {
+        super();
+        this.closed = false;
+        this.origin = opts.origin ?? randomId();
+        let ch = opts.channel;
+        if (!ch) {
+            const BC = globalThis
+                .BroadcastChannel;
+            if (!BC) {
+                throw new Error('BroadcastChannel is not available in this runtime. Pass `channel` ' +
+                    '(e.g. from the `broadcast-channel` npm package) to BroadcastChannelMailbox.');
+            }
+            ch = new BC(opts.channelName ?? 'anyclaude-team');
+        }
+        this.channel = ch;
+        // Normalize both delivery shapes: native BroadcastChannel hands the listener
+        // a MessageEvent ({data}); the `broadcast-channel` polyfill hands it the raw
+        // payload. Accept either, then de-dupe via the protected ingest().
+        const handle = (arg) => {
+            if (this.closed)
+                return;
+            let data = arg;
+            if (!isWire(arg) && arg && typeof arg === 'object' && 'data' in arg) {
+                data = arg.data;
+            }
+            if (isWire(data) && data.origin !== this.origin)
+                this.ingest(data.message);
+        };
+        // Single registration: addEventListener when available (native + polyfill
+        // both support it), otherwise the onmessage setter.
+        if (typeof this.channel.addEventListener === 'function') {
+            this.channel.addEventListener('message', handle);
+        }
+        else {
+            this.channel.onmessage = (ev) => handle(ev);
+        }
+    }
+    /** Send a message: append to the local replica and broadcast to peers. */
+    send(from, to, text) {
+        // Globally-unique id: origin-scoped so two workers never collide.
+        const id = `msg_${this.origin}_${++this.counter}`;
+        const m = { id, from, to, text, ts: Date.now(), read: false };
+        this.ingest(m);
+        if (!this.closed) {
+            const wire = { __ac: 'msg', origin: this.origin, message: m };
+            this.channel.postMessage(wire);
+        }
+        return id;
+    }
+    /** Stop listening and release the channel. Safe to call more than once. */
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.channel.close?.();
+    }
+}

package/dist/team/index.d.ts

@@ -1,4 +1,5 @@
 export { Mailbox, type AgentMessage } from './mailbox.js';
+export { BroadcastChannelMailbox, type ChannelLike, type BroadcastChannelMailboxOptions, } from './broadcast-mailbox.js';
 export { TaskBoard, type BoardTask, type TaskStatus } from './taskBoard.js';
 export { TEAM_TOOLS, sendMessage, taskCreate, taskUpdate, taskGet, boardList, } from './tools.js';
 export { coordinatorPrompt } from './prompt.js';

package/dist/team/index.js

@@ -1,6 +1,7 @@
 // Teammate/coordinator MVP: shared in-memory mailbox + task board, the tools
 // the coordinator uses to delegate, and the coordinator system-prompt addendum.
 export { Mailbox } from './mailbox.js';
+export { BroadcastChannelMailbox, } from './broadcast-mailbox.js';
 export { TaskBoard } from './taskBoard.js';
 export { TEAM_TOOLS, sendMessage, taskCreate, taskUpdate, taskGet, boardList, } from './tools.js';
 export { coordinatorPrompt } from './prompt.js';

package/dist/team/mailbox.d.ts

@@ -7,10 +7,13 @@ export type AgentMessage = {
     read: boolean;
 };
 export declare class Mailbox {
-    private messages;
-    private counter;
+    protected messages: AgentMessage[];
+    protected counter: number;
     /** Deliver a message; returns the message id. */
     send(from: string, to: string, text: string): string;
+    /** Append a message produced elsewhere (e.g. another worker), de-duped by id.
+     *  Subclasses that sync over a transport use this for inbound messages. */
+    protected ingest(m: AgentMessage): void;
     /** Messages addressed to `agentId`, oldest first. */
     inbox(agentId: string, opts?: {
         unreadOnly?: boolean;

package/dist/team/mailbox.js

@@ -12,6 +12,13 @@ export class Mailbox {
         this.messages.push({ id, from, to, text, ts: Date.now(), read: false });
         return id;
     }
+    /** Append a message produced elsewhere (e.g. another worker), de-duped by id.
+     *  Subclasses that sync over a transport use this for inbound messages. */
+    ingest(m) {
+        if (this.messages.some((x) => x.id === m.id))
+            return;
+        this.messages.push(m);
+    }
     /** Messages addressed to `agentId`, oldest first. */
     inbox(agentId, opts) {
         return this.messages.filter((m) => m.to === agentId && (!opts?.unreadOnly || !m.read));

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.7.1";
+export declare const TELEMETRY_SDK_VERSION = "0.10.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.7.1';
+export const TELEMETRY_SDK_VERSION = '0.10.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.9.0",
+  "version": "0.10.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",