@particle-academy/agent-integrations 0.41.0 → 0.43.0

package/dist/components-shared-whiteboard.js

@@ -1,11 +1,11 @@
 import { ShareControls, AgentCursor, AgentActivityHighlight, AgentPanel } from './chunk-QDC7MXBH.js';
 import { createSessionDescriptor, attachSseRelay } from './chunk-6TZ5IBRN.js';
 import { attachInProcess } from './chunk-AFUULW5E.js';
-import { registerWhiteboardBridge } from './chunk-2U5JB6ZA.js';
-import './chunk-CT3LRNH7.js';
+import { registerWhiteboardBridge } from './chunk-2LSU3NFO.js';
+import './chunk-HVDHT7DM.js';
 import './chunk-2VENWGLZ.js';
 import './chunk-C3TYI5TJ.js';
-import { MicroMcpServer } from './chunk-DF3PLL2E.js';
+import { MicroMcpServer } from './chunk-QJYRWEXD.js';
 import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
 import { Board, Connector, Shape, StickyNote, CursorLayer } from '@particle-academy/fancy-whiteboard';
 import { jsxs, jsx } from 'react/jsx-runtime';

package/dist/index.cjs

@@ -44,14 +44,37 @@ var MCP_PROTOCOL_VERSION = "2025-06-18";
 var ToolRegistry = class {
   constructor() {
     this.tools = /* @__PURE__ */ new Map();
+    /**
+     * Tools that existed and were withdrawn, kept so a call that races an unmount
+     * can say WHICH thing happened.
+     *
+     * The tool surface is dynamic by design — "site tools always, page tools while
+     * mounted" — so an agent deciding to call a tool while the human navigates
+     * away is normal traffic, not an edge case. Reporting that as `Unknown tool`
+     * is the least useful thing available: it reads as "the agent is broken" or
+     * "you asked for something imaginary", when the truth is "that surface just
+     * closed".
+     *
+     * Names only. Nothing about the handler is retained, so this cannot keep a
+     * disposed surface alive.
+     */
+    this.withdrawn = /* @__PURE__ */ new Set();
   }
   registerTool(definition, handler) {
     this.tools.set(definition.name, { definition, handler });
+    this.withdrawn.delete(definition.name);
     this.onToolsChanged();
     return () => {
-      if (this.tools.delete(definition.name)) this.onToolsChanged();
+      if (this.tools.delete(definition.name)) {
+        this.withdrawn.add(definition.name);
+        this.onToolsChanged();
+      }
     };
   }
+  /** Why `name` is not callable, phrased for whoever has to act on it. */
+  missingToolMessage(name) {
+    return this.withdrawn.has(name) ? `Tool "${name}" was withdrawn: the surface it targets is no longer mounted. Call tools/list for the current surface \u2014 the site-wide tools remain available.` : `Unknown tool: ${name}`;
+  }
   getTool(name) {
     return this.tools.get(name) ?? null;
   }
@@ -61,7 +84,7 @@ var ToolRegistry = class {
   async callTool(name, args = {}) {
     const tool = this.tools.get(name);
     if (!tool) {
-      throw new Error(`Unknown tool: ${name}`);
+      throw new Error(this.missingToolMessage(name));
     }
     return tool.handler(args);
   }
@@ -142,7 +165,7 @@ var MicroMcpServer = class extends ToolRegistry {
         }
         const tool = this.tools.get(name);
         if (!tool) {
-          throw rpcError(JSONRPC_METHOD_NOT_FOUND, `Unknown tool: ${name}`);
+          throw rpcError(JSONRPC_METHOD_NOT_FOUND, this.missingToolMessage(name));
         }
         const result = await tool.handler(args, { transport });
         return result;
@@ -4999,6 +5022,58 @@ function attachSseRelay(server, options) {
 
 // src/sharing/use-co-browse-session.ts
 init_registry();
+
+// src/sharing/bridge-contributions.ts
+var BridgeContributions = class {
+  constructor() {
+    this.contributions = /* @__PURE__ */ new Map();
+    this.applied = /* @__PURE__ */ new Map();
+    this.server = null;
+  }
+  /**
+   * Contribute bridges for as long as the returned disposer is uncalled.
+   *
+   * Applies immediately when a server is already live, and is held for the next
+   * one otherwise — so a page need not know whether sharing has started.
+   */
+  add(contribute) {
+    const key = /* @__PURE__ */ Symbol("bridge-contribution");
+    this.contributions.set(key, contribute);
+    if (this.server) this.apply(key, contribute, this.server);
+    return () => {
+      this.contributions.delete(key);
+      this.withdraw(key);
+    };
+  }
+  /** Attach a server and apply every live contribution to it. */
+  bind(server) {
+    if (this.server === server) return;
+    if (this.server) this.unbind();
+    this.server = server;
+    for (const [key, contribute] of this.contributions) this.apply(key, contribute, server);
+  }
+  /**
+   * Detach the current server, withdrawing what was applied to it. Contributions
+   * themselves are KEPT: a session can be stopped and restarted under a page
+   * that never unmounted, and its tools must come back rather than silently
+   * vanish.
+   */
+  unbind() {
+    for (const key of [...this.applied.keys()]) this.withdraw(key);
+    this.server = null;
+  }
+  apply(key, contribute, server) {
+    const dispose = contribute(server);
+    if (typeof dispose === "function") this.applied.set(key, dispose);
+  }
+  withdraw(key) {
+    const dispose = this.applied.get(key);
+    this.applied.delete(key);
+    dispose?.();
+  }
+};
+
+// src/sharing/use-co-browse-session.ts
 var DEFAULT_AGENT17 = { id: "agent", name: "Agent", color: "#a855f7" };
 var USER = { id: "human", name: "You" };
 function useCoBrowseSession(options) {
@@ -5006,6 +5081,8 @@ function useCoBrowseSession(options) {
   const agent = { ...DEFAULT_AGENT17, ...options.agent ?? {} };
   const relayBaseUrl = options.relayBaseUrl ?? "/agent-relay";
   const serverRef = react.useRef(null);
+  const contributionsRef = react.useRef(null);
+  if (!contributionsRef.current) contributionsRef.current = new BridgeContributions();
   const relayRef = react.useRef(null);
   const detachInProc = react.useRef(null);
   const disposeBridge = react.useRef(null);
@@ -5019,6 +5096,7 @@ function useCoBrowseSession(options) {
     });
     const bridge = registerNavigationBridge(server, { adapter, agent, pendingMode: options.pendingMode });
     extraBridges?.(server);
+    contributionsRef.current.bind(server);
     const inProc = attachInProcess(server);
     detachInProc.current = () => inProc.close();
     disposeBridge.current = bridge.dispose;
@@ -5026,6 +5104,7 @@ function useCoBrowseSession(options) {
     return () => {
       relayRef.current?.close();
       relayRef.current = null;
+      contributionsRef.current.unbind();
       disposeBridge.current?.();
       detachInProc.current?.();
       serverRef.current = null;
@@ -5084,8 +5163,13 @@ function useCoBrowseSession(options) {
       meta: event
     });
   }, []);
+  const contributeBridges = react.useCallback(
+    (contribute) => contributionsRef.current.add(contribute),
+    []
+  );
   return {
     server: serverRef.current,
+    contributeBridges,
     session,
     relayState,
     agentConnected: agentCount > 0,
@@ -6283,6 +6367,7 @@ Object.defineProperty(exports, "undoOne", {
 exports.AgentActivityHighlight = AgentActivityHighlight;
 exports.AgentCursor = AgentCursor;
 exports.AgentPanel = AgentPanel;
+exports.BridgeContributions = BridgeContributions;
 exports.BridgedForm = BridgedForm;
 exports.CLAUDE_CONNECTORS_URL = CLAUDE_CONNECTORS_URL;
 exports.CONNECTOR_GLYPHS = CONNECTOR_GLYPHS;