@particle-academy/agent-integrations 0.40.0 → 0.42.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;
@@ -2800,6 +2823,13 @@ function registerGitBridge(host, options) {
 // src/bridges/files.ts
 var DEFAULT_AGENT10 = { id: "agent", name: "Agent", color: "#a855f7" };
 var MAX_SNAPSHOT_DEPTH = 8;
+function invalidFolderName(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") return "A folder name is required.";
+  if (trimmed.includes("/") || trimmed.includes("\\")) return "A folder name may not contain a path separator.";
+  if (trimmed === "." || trimmed === "..") return "That folder name is reserved.";
+  return null;
+}
 function assertPathWithinRoot(root, path) {
   const segments = path.replace(/[\\/]+/g, "/").split("/");
   if (segments.includes("..")) {
@@ -2829,6 +2859,7 @@ var asPaths = (v) => {
 function registerFilesBridge(host, options) {
   const { adapter } = options;
   const agent = { ...DEFAULT_AGENT10, ...options.agent ?? {} };
+  const pendingMode = options.pendingMode ?? true;
   const disposers = [];
   const guard = (path) => {
     if (options.root !== void 0) assertPathWithinRoot(options.root, path);
@@ -2995,6 +3026,42 @@ function registerFilesBridge(host, options) {
     },
     fTarget
   );
+  if (adapter.createFolder) {
+    reg(
+      "files_create_folder",
+      "Create a folder inside `parentPath`. Staged for human confirmation unless the host disabled pendingMode.",
+      {
+        parentPath: { type: "string", description: "Directory to create in; defaults to the current directory." },
+        name: { type: "string", description: "The new folder's name. A leaf name \u2014 no separators." },
+        confirm: { type: "boolean", description: "Acknowledge a staged write when the host wired no confirm hook." }
+      },
+      ["name"],
+      async (args) => {
+        const parentPath = guard(args.parentPath !== void 0 ? str3(args.parentPath) : adapter.getPath());
+        const name = str3(args.name).trim();
+        const invalid = invalidFolderName(name);
+        if (invalid) return errorResult(invalid);
+        const label = `${parentPath}/${name}`;
+        if (pendingMode) {
+          if (options.confirm) {
+            const ok = await options.confirm({ action: "files_create_folder", path: label, label });
+            if (!ok) return errorResult(`Declined: create folder ${label} (human did not confirm).`);
+          } else if (args.confirm !== true) {
+            return errorResult(
+              `Staged: create folder ${label}. Re-call with confirm:true to proceed.`
+            );
+          }
+        }
+        try {
+          await adapter.createFolder({ parentPath, name });
+        } catch (e) {
+          return errorResult(e instanceof Error ? e.message : String(e));
+        }
+        return textResult(`Created folder ${label}.`, { parentPath, name, path: label });
+      },
+      (args) => ({ kind: "directory", path: `${str3(args.parentPath)}/${str3(args.name)}`, label: str3(args.name) })
+    );
+  }
   reg(
     "files_request_snapshot",
     "Request a fresh snapshot subtree rooted at `path` (snapshot mode) \u2014 e.g. to pull a remote machine's current tree. Requires the host to wire requestSnapshot.",
@@ -4955,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) {
@@ -4962,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);
@@ -4975,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;
@@ -4982,6 +5104,7 @@ function useCoBrowseSession(options) {
     return () => {
       relayRef.current?.close();
       relayRef.current = null;
+      contributionsRef.current.unbind();
       disposeBridge.current?.();
       detachInProc.current?.();
       serverRef.current = null;
@@ -5040,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,
@@ -6239,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;