@particle-academy/agent-integrations 0.2.4 → 0.4.0

package/dist/tool-host-C8JMMGYq.d.ts

@@ -0,0 +1,60 @@
+import { T as ToolDefinition, b as ToolHandler, R as RegisteredTool, c as JsonObject, C as CallToolResult } from './types-aOQLTW0E.js';
+
+/**
+ * ToolHost — the minimal surface a bridge needs to register its tools.
+ *
+ * Bridges (whiteboard, flow, sheets, code, charts, screens, scene, form)
+ * speak only through this interface. The MCP server implements it
+ * alongside its transport / JSON-RPC duties, and the standalone
+ * {@link ToolRegistry} implements it for in-process agents that don't
+ * need any of MCP's wire framing.
+ *
+ * Net effect: every bridge works equally well behind an MCP server
+ * (browser ↔ external agents over SSE) or behind a plain registry
+ * (in-process agent calling `host.callTool("sheet_set_cell", { … })`).
+ */
+interface ToolHost {
+    /** Register a tool. Returns a disposer that unregisters it. */
+    registerTool(definition: ToolDefinition, handler: ToolHandler): () => void;
+    /** Look up an already-registered tool's definition + handler, or null. */
+    getTool(name: string): RegisteredTool | null;
+    /** Snapshot of all currently-registered tool definitions. */
+    listTools(): ToolDefinition[];
+    /**
+     * Invoke a registered tool directly, bypassing any transport layer.
+     * Throws if no tool is registered under `name`.
+     *
+     * This is the single entry point in-process agents use to drive the
+     * surface — no JSON-RPC framing, no transport plumbing.
+     */
+    callTool(name: string, args?: JsonObject): Promise<CallToolResult>;
+}
+/**
+ * Standalone in-memory ToolHost. Use this when no MCP server is needed —
+ * e.g. an in-process agent that just wants to register the same bridges
+ * and call them directly.
+ *
+ * Example:
+ *
+ *   const host = new ToolRegistry();
+ *   registerSheetsBridge(host, { adapter });
+ *   const result = await host.callTool("sheet_set_cell", { address: "B3", value: 42 });
+ *
+ * Pair with a MicroMcpServer in the same app to expose the same tools
+ * to remote agents over SSE while in-process agents still get
+ * zero-overhead direct calls.
+ */
+declare class ToolRegistry implements ToolHost {
+    protected readonly tools: Map<string, RegisteredTool>;
+    registerTool(definition: ToolDefinition, handler: ToolHandler): () => void;
+    getTool(name: string): RegisteredTool | null;
+    listTools(): ToolDefinition[];
+    callTool(name: string, args?: JsonObject): Promise<CallToolResult>;
+    /**
+     * Hook for subclasses (e.g. MicroMcpServer) to notify subscribers
+     * when the tool catalog changes. Default no-op.
+     */
+    protected onToolsChanged(): void;
+}
+
+export { type ToolHost as T, ToolRegistry as a };

package/dist/{types-CRPA_D0z.d.ts → types-CCSBGW9T.d.cts}

@@ -1,4 +1,4 @@
-import { M as MicroMcpServer } from './server-Bv985us3.js';
+import { T as ToolHost } from './tool-host-BQuUygLF.cjs';
 
 /**
  * Bridge — registers a cohesive set of MCP tools/resources for a single
@@ -13,6 +13,6 @@ type Bridge = {
     /** Disposes the bridge. Must remove every tool it registered. */
     dispose: () => void;
 };
-type BridgeFactory<TOptions> = (server: MicroMcpServer, options: TOptions) => Bridge;
+type BridgeFactory<TOptions> = (host: ToolHost, options: TOptions) => Bridge;
 
 export type { Bridge as B, BridgeFactory as a };

package/dist/{types-DR5AS6Rd.d.cts → types-DIVNcIQO.d.ts}

@@ -1,4 +1,4 @@
-import { M as MicroMcpServer } from './server-Bv985us3.cjs';
+import { T as ToolHost } from './tool-host-C8JMMGYq.js';
 
 /**
  * Bridge — registers a cohesive set of MCP tools/resources for a single
@@ -13,6 +13,6 @@ type Bridge = {
     /** Disposes the bridge. Must remove every tool it registered. */
     dispose: () => void;
 };
-type BridgeFactory<TOptions> = (server: MicroMcpServer, options: TOptions) => Bridge;
+type BridgeFactory<TOptions> = (host: ToolHost, options: TOptions) => Bridge;
 
 export type { Bridge as B, BridgeFactory as a };

package/dist/types-aOQLTW0E.d.cts

@@ -0,0 +1,112 @@
+/**
+ * Minimal MCP (Model Context Protocol) types — covers the subset this
+ * package implements: initialize, tools/list, tools/call, plus JSON-RPC.
+ *
+ * Aligned with the public MCP spec but trimmed to v0.1 needs. See
+ * https://spec.modelcontextprotocol.io/ for the full surface.
+ */
+type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonRpcId = string | number | null;
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: JsonValue;
+};
+type JsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+};
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccess | JsonRpcError;
+declare const JSONRPC_PARSE_ERROR = -32700;
+declare const JSONRPC_INVALID_REQUEST = -32600;
+declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+declare const JSONRPC_INVALID_PARAMS = -32602;
+declare const JSONRPC_INTERNAL_ERROR = -32603;
+type ServerCapabilities = {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        listChanged?: boolean;
+        subscribe?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+};
+type ServerInfo = {
+    name: string;
+    version: string;
+    title?: string;
+};
+type InitializeResult = {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: ServerInfo;
+    instructions?: string;
+};
+type ToolInputSchema = {
+    type: "object";
+    properties?: Record<string, JsonValue>;
+    required?: string[];
+    additionalProperties?: boolean;
+};
+type ToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: ToolInputSchema;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        text?: string;
+        mimeType?: string;
+    };
+};
+type CallToolResult = {
+    content: ContentBlock[];
+    isError?: boolean;
+    /** Structured tool output — non-spec but useful for typed bridges. */
+    structuredContent?: JsonValue;
+};
+/** Handler signature for a tool registered on the MicroMcpServer. */
+type ToolHandler = (args: JsonObject) => Promise<CallToolResult> | CallToolResult;
+/** Internal record kept by the server. */
+type RegisteredTool = {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+export { type CallToolResult as C, type InitializeResult as I, type JsonRpcMessage as J, MCP_PROTOCOL_VERSION as M, type RegisteredTool as R, type ServerInfo as S, type ToolDefinition as T, type ServerCapabilities as a, type ToolHandler as b, type JsonObject as c, type ContentBlock as d, type JsonRpcNotification as e, type JsonRpcRequest as f, type JsonValue as g, JSONRPC_INTERNAL_ERROR as h, JSONRPC_INVALID_PARAMS as i, JSONRPC_INVALID_REQUEST as j, JSONRPC_METHOD_NOT_FOUND as k, JSONRPC_PARSE_ERROR as l, type JsonRpcError as m, type JsonRpcId as n, type JsonRpcSuccess as o, type ToolInputSchema as p };

package/dist/types-aOQLTW0E.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Minimal MCP (Model Context Protocol) types — covers the subset this
+ * package implements: initialize, tools/list, tools/call, plus JSON-RPC.
+ *
+ * Aligned with the public MCP spec but trimmed to v0.1 needs. See
+ * https://spec.modelcontextprotocol.io/ for the full surface.
+ */
+type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonRpcId = string | number | null;
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: JsonValue;
+};
+type JsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+};
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccess | JsonRpcError;
+declare const JSONRPC_PARSE_ERROR = -32700;
+declare const JSONRPC_INVALID_REQUEST = -32600;
+declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+declare const JSONRPC_INVALID_PARAMS = -32602;
+declare const JSONRPC_INTERNAL_ERROR = -32603;
+type ServerCapabilities = {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        listChanged?: boolean;
+        subscribe?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+};
+type ServerInfo = {
+    name: string;
+    version: string;
+    title?: string;
+};
+type InitializeResult = {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: ServerInfo;
+    instructions?: string;
+};
+type ToolInputSchema = {
+    type: "object";
+    properties?: Record<string, JsonValue>;
+    required?: string[];
+    additionalProperties?: boolean;
+};
+type ToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: ToolInputSchema;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        text?: string;
+        mimeType?: string;
+    };
+};
+type CallToolResult = {
+    content: ContentBlock[];
+    isError?: boolean;
+    /** Structured tool output — non-spec but useful for typed bridges. */
+    structuredContent?: JsonValue;
+};
+/** Handler signature for a tool registered on the MicroMcpServer. */
+type ToolHandler = (args: JsonObject) => Promise<CallToolResult> | CallToolResult;
+/** Internal record kept by the server. */
+type RegisteredTool = {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+export { type CallToolResult as C, type InitializeResult as I, type JsonRpcMessage as J, MCP_PROTOCOL_VERSION as M, type RegisteredTool as R, type ServerInfo as S, type ToolDefinition as T, type ServerCapabilities as a, type ToolHandler as b, type JsonObject as c, type ContentBlock as d, type JsonRpcNotification as e, type JsonRpcRequest as f, type JsonValue as g, JSONRPC_INTERNAL_ERROR as h, JSONRPC_INVALID_PARAMS as i, JSONRPC_INVALID_REQUEST as j, JSONRPC_METHOD_NOT_FOUND as k, JSONRPC_PARSE_ERROR as l, type JsonRpcError as m, type JsonRpcId as n, type JsonRpcSuccess as o, type ToolInputSchema as p };

package/dist/undo/index.d.cts

@@ -0,0 +1,69 @@
+import { T as ToolHost } from '../tool-host-BQuUygLF.cjs';
+import '../types-aOQLTW0E.cjs';
+
+/**
+ * Generic undo/redo stack keyed by `agentId`. Each entry holds:
+ *  - `do` — re-applies the action (for redo)
+ *  - `undo` — reverses it
+ *  - `label` — human-readable summary surfaced in agent_history
+ *
+ * Bridges register entries by calling `pushUndoEntry` after a successful
+ * mutation. The corresponding MCP tools (`agent_undo`, `agent_redo`,
+ * `agent_history`) are registered once per server via `registerUndoTools`.
+ *
+ * Stacks are per-agent so multiple agents can rewind independently.
+ */
+type UndoEntry = {
+    /** Wall-clock ms. */
+    timestamp: number;
+    /** Bridge id (e.g. "whiteboard", "form:signup"). */
+    bridgeId: string;
+    /** Tool name that produced the entry. */
+    action: string;
+    /** Short human label, e.g. `Added sticky n_abc`. */
+    label: string;
+    /** Reverse the action. */
+    undo: () => void | Promise<void>;
+    /** Re-apply the action (used when redoing after an undo). */
+    redo: () => void | Promise<void>;
+};
+/** Push a new undo entry on the agent's stack. Clears the redo (future) stack. */
+declare function pushUndoEntry(agentId: string, entry: UndoEntry): void;
+/** Pop and undo the most recent entry. Returns the entry that ran, or null. */
+declare function undoOne(agentId: string): Promise<UndoEntry | null>;
+/** Re-apply the most recently undone entry. Returns it, or null if no future. */
+declare function redoOne(agentId: string): Promise<UndoEntry | null>;
+/** Read the past stack (oldest first). */
+declare function readHistory(agentId: string): UndoEntry[];
+/** Wipe an agent's stacks. */
+declare function clearStack(agentId: string): void;
+/** Test/teardown helper. */
+declare function resetAllUndoStacks(): void;
+
+type UndoToolsOptions = {
+    /** Default agent id when the caller doesn't pass one. */
+    defaultAgentId?: string;
+};
+/**
+ * ensureUndoToolsRegistered — bridges call this on construction. Safe to
+ * call repeatedly with the same server; subsequent calls are no-ops.
+ */
+declare function ensureUndoToolsRegistered(host: ToolHost, options?: UndoToolsOptions): void;
+/**
+ * registerUndoTools — add agent_undo / agent_redo / agent_history to the
+ * server. Returns a disposer that unregisters all three.
+ */
+declare function registerUndoTools(host: ToolHost, options?: UndoToolsOptions): () => void;
+
+/**
+ * useUndoStack — minimal React snapshot of an agent's history. Polls every
+ * `intervalMs` (default 500). Use this to render an inline "agent timeline"
+ * in a sidebar or activity panel. No subscription model in v1 — keeping it
+ * simple; bridge mutations are infrequent enough that polling is fine.
+ */
+declare function useUndoStack(agentId: string, intervalMs?: number): {
+    history: UndoEntry[];
+    refresh: () => void;
+};
+
+export { type UndoEntry, type UndoToolsOptions, clearStack, ensureUndoToolsRegistered, pushUndoEntry, readHistory, redoOne, registerUndoTools, resetAllUndoStacks, undoOne, useUndoStack };

package/dist/undo/index.d.ts

@@ -0,0 +1,69 @@
+import { T as ToolHost } from '../tool-host-C8JMMGYq.js';
+import '../types-aOQLTW0E.js';
+
+/**
+ * Generic undo/redo stack keyed by `agentId`. Each entry holds:
+ *  - `do` — re-applies the action (for redo)
+ *  - `undo` — reverses it
+ *  - `label` — human-readable summary surfaced in agent_history
+ *
+ * Bridges register entries by calling `pushUndoEntry` after a successful
+ * mutation. The corresponding MCP tools (`agent_undo`, `agent_redo`,
+ * `agent_history`) are registered once per server via `registerUndoTools`.
+ *
+ * Stacks are per-agent so multiple agents can rewind independently.
+ */
+type UndoEntry = {
+    /** Wall-clock ms. */
+    timestamp: number;
+    /** Bridge id (e.g. "whiteboard", "form:signup"). */
+    bridgeId: string;
+    /** Tool name that produced the entry. */
+    action: string;
+    /** Short human label, e.g. `Added sticky n_abc`. */
+    label: string;
+    /** Reverse the action. */
+    undo: () => void | Promise<void>;
+    /** Re-apply the action (used when redoing after an undo). */
+    redo: () => void | Promise<void>;
+};
+/** Push a new undo entry on the agent's stack. Clears the redo (future) stack. */
+declare function pushUndoEntry(agentId: string, entry: UndoEntry): void;
+/** Pop and undo the most recent entry. Returns the entry that ran, or null. */
+declare function undoOne(agentId: string): Promise<UndoEntry | null>;
+/** Re-apply the most recently undone entry. Returns it, or null if no future. */
+declare function redoOne(agentId: string): Promise<UndoEntry | null>;
+/** Read the past stack (oldest first). */
+declare function readHistory(agentId: string): UndoEntry[];
+/** Wipe an agent's stacks. */
+declare function clearStack(agentId: string): void;
+/** Test/teardown helper. */
+declare function resetAllUndoStacks(): void;
+
+type UndoToolsOptions = {
+    /** Default agent id when the caller doesn't pass one. */
+    defaultAgentId?: string;
+};
+/**
+ * ensureUndoToolsRegistered — bridges call this on construction. Safe to
+ * call repeatedly with the same server; subsequent calls are no-ops.
+ */
+declare function ensureUndoToolsRegistered(host: ToolHost, options?: UndoToolsOptions): void;
+/**
+ * registerUndoTools — add agent_undo / agent_redo / agent_history to the
+ * server. Returns a disposer that unregisters all three.
+ */
+declare function registerUndoTools(host: ToolHost, options?: UndoToolsOptions): () => void;
+
+/**
+ * useUndoStack — minimal React snapshot of an agent's history. Polls every
+ * `intervalMs` (default 500). Use this to render an inline "agent timeline"
+ * in a sidebar or activity panel. No subscription model in v1 — keeping it
+ * simple; bridge mutations are infrequent enough that polling is fine.
+ */
+declare function useUndoStack(agentId: string, intervalMs?: number): {
+    history: UndoEntry[];
+    refresh: () => void;
+};
+
+export { type UndoEntry, type UndoToolsOptions, clearStack, ensureUndoToolsRegistered, pushUndoEntry, readHistory, redoOne, registerUndoTools, resetAllUndoStacks, undoOne, useUndoStack };

package/dist/undo.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+var react = require('react');
+
+// src/undo/undo-stack.ts
+var stacks = /* @__PURE__ */ new Map();
+var CAP = 200;
+function getStack(agentId) {
+  let s = stacks.get(agentId);
+  if (!s) {
+    s = { past: [], future: [] };
+    stacks.set(agentId, s);
+  }
+  return s;
+}
+function pushUndoEntry(agentId, entry) {
+  const s = getStack(agentId);
+  s.past.push(entry);
+  if (s.past.length > CAP) s.past.splice(0, s.past.length - CAP);
+  s.future.length = 0;
+}
+async function undoOne(agentId) {
+  const s = getStack(agentId);
+  const entry = s.past.pop();
+  if (!entry) return null;
+  await entry.undo();
+  s.future.push(entry);
+  return entry;
+}
+async function redoOne(agentId) {
+  const s = getStack(agentId);
+  const entry = s.future.pop();
+  if (!entry) return null;
+  await entry.redo();
+  s.past.push(entry);
+  return entry;
+}
+function readHistory(agentId) {
+  return getStack(agentId).past.slice();
+}
+function clearStack(agentId) {
+  stacks.delete(agentId);
+}
+function resetAllUndoStacks() {
+  stacks.clear();
+}
+
+// src/mcp/server.ts
+function textResult(text, structured) {
+  return {
+    content: [{ type: "text", text }],
+    ...structured !== void 0 ? { structuredContent: structured } : {}
+  };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/undo/undo-tools.ts
+var installedHosts = /* @__PURE__ */ new WeakSet();
+function ensureUndoToolsRegistered(host, options = {}) {
+  if (installedHosts.has(host)) return;
+  installedHosts.add(host);
+  registerUndoTools(host, options);
+}
+function registerUndoTools(host, options = {}) {
+  const defaultAgent = options.defaultAgentId ?? "agent";
+  const disposers = [];
+  const agentOf = (args) => typeof args?.agentId === "string" ? args.agentId : defaultAgent;
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_undo",
+        description: "Undo the most recent action on the agent's stack. Optional agentId targets a specific agent.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const entry = await undoOne(agentOf(args));
+        if (!entry) return errorResult("Nothing to undo.");
+        return textResult(`Undid: ${entry.label}`, { entry: serialize(entry) });
+      }
+    )
+  );
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_redo",
+        description: "Redo the most recently undone action.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const entry = await redoOne(agentOf(args));
+        if (!entry) return errorResult("Nothing to redo.");
+        return textResult(`Redid: ${entry.label}`, { entry: serialize(entry) });
+      }
+    )
+  );
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_history",
+        description: "List the agent's undo stack (oldest first). Useful for understanding what's reversible.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const history = readHistory(agentOf(args)).map(serialize);
+        const text = history.map((e) => `${new Date(e.timestamp).toISOString()} ${e.bridgeId} ${e.action}: ${e.label}`).join("\n");
+        return textResult(text || "(empty)", history);
+      }
+    )
+  );
+  return () => disposers.forEach((d) => d());
+}
+function serialize(entry) {
+  return {
+    timestamp: entry.timestamp,
+    bridgeId: entry.bridgeId,
+    action: entry.action,
+    label: entry.label
+  };
+}
+function useUndoStack(agentId, intervalMs = 500) {
+  const [history, setHistory] = react.useState(() => readHistory(agentId));
+  react.useEffect(() => {
+    let cancelled = false;
+    const tick = () => {
+      if (cancelled) return;
+      setHistory(readHistory(agentId));
+    };
+    const id = setInterval(tick, intervalMs);
+    tick();
+    return () => {
+      cancelled = true;
+      clearInterval(id);
+    };
+  }, [agentId, intervalMs]);
+  const refresh = react.useCallback(() => setHistory(readHistory(agentId)), [agentId]);
+  return { history, refresh };
+}
+
+exports.clearStack = clearStack;
+exports.ensureUndoToolsRegistered = ensureUndoToolsRegistered;
+exports.pushUndoEntry = pushUndoEntry;
+exports.readHistory = readHistory;
+exports.redoOne = redoOne;
+exports.registerUndoTools = registerUndoTools;
+exports.resetAllUndoStacks = resetAllUndoStacks;
+exports.undoOne = undoOne;
+exports.useUndoStack = useUndoStack;
+//# sourceMappingURL=undo.cjs.map
+//# sourceMappingURL=undo.cjs.map

package/dist/undo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/undo/undo-stack.ts","../src/mcp/server.ts","../src/undo/undo-tools.ts","../src/undo/use-undo-stack.ts"],"names":["useState","useEffect","useCallback"],"mappings":"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","file":"undo.cjs","sourcesContent":["/**\n * Generic undo/redo stack keyed by `agentId`. Each entry holds:\n *  - `do` — re-applies the action (for redo)\n *  - `undo` — reverses it\n *  - `label` — human-readable summary surfaced in agent_history\n *\n * Bridges register entries by calling `pushUndoEntry` after a successful\n * mutation. The corresponding MCP tools (`agent_undo`, `agent_redo`,\n * `agent_history`) are registered once per server via `registerUndoTools`.\n *\n * Stacks are per-agent so multiple agents can rewind independently.\n */\n\nexport type UndoEntry = {\n  /** Wall-clock ms. */\n  timestamp: number;\n  /** Bridge id (e.g. \"whiteboard\", \"form:signup\"). */\n  bridgeId: string;\n  /** Tool name that produced the entry. */\n  action: string;\n  /** Short human label, e.g. `Added sticky n_abc`. */\n  label: string;\n  /** Reverse the action. */\n  undo: () => void | Promise<void>;\n  /** Re-apply the action (used when redoing after an undo). */\n  redo: () => void | Promise<void>;\n};\n\ntype Stack = { past: UndoEntry[]; future: UndoEntry[] };\n\nconst stacks = new Map<string, Stack>();\nconst CAP = 200;\n\nfunction getStack(agentId: string): Stack {\n  let s = stacks.get(agentId);\n  if (!s) {\n    s = { past: [], future: [] };\n    stacks.set(agentId, s);\n  }\n  return s;\n}\n\n/** Push a new undo entry on the agent's stack. Clears the redo (future) stack. */\nexport function pushUndoEntry(agentId: string, entry: UndoEntry): void {\n  const s = getStack(agentId);\n  s.past.push(entry);\n  if (s.past.length > CAP) s.past.splice(0, s.past.length - CAP);\n  s.future.length = 0;\n}\n\n/** Pop and undo the most recent entry. Returns the entry that ran, or null. */\nexport async function undoOne(agentId: string): Promise<UndoEntry | null> {\n  const s = getStack(agentId);\n  const entry = s.past.pop();\n  if (!entry) return null;\n  await entry.undo();\n  s.future.push(entry);\n  return entry;\n}\n\n/** Re-apply the most recently undone entry. Returns it, or null if no future. */\nexport async function redoOne(agentId: string): Promise<UndoEntry | null> {\n  const s = getStack(agentId);\n  const entry = s.future.pop();\n  if (!entry) return null;\n  await entry.redo();\n  s.past.push(entry);\n  return entry;\n}\n\n/** Read the past stack (oldest first). */\nexport function readHistory(agentId: string): UndoEntry[] {\n  return getStack(agentId).past.slice();\n}\n\n/** Wipe an agent's stacks. */\nexport function clearStack(agentId: string): void {\n  stacks.delete(agentId);\n}\n\n/** Test/teardown helper. */\nexport function resetAllUndoStacks(): void {\n  stacks.clear();\n}\n","import {\n  type CallToolResult,\n  type JsonObject,\n  type JsonRpcMessage,\n  type JsonRpcRequest,\n  type JsonRpcId,\n  type RegisteredTool,\n  type ServerCapabilities,\n  type ServerInfo,\n  type ToolDefinition,\n  type ToolHandler,\n  JSONRPC_INTERNAL_ERROR,\n  JSONRPC_INVALID_PARAMS,\n  JSONRPC_METHOD_NOT_FOUND,\n  MCP_PROTOCOL_VERSION,\n} from \"./types\";\nimport { ToolRegistry } from \"./tool-host\";\n\nexport type McpServerOptions = {\n  info: ServerInfo;\n  /** Defaults to { tools: { listChanged: true } } */\n  capabilities?: ServerCapabilities;\n  /** Free-text instructions surfaced to clients during initialize. */\n  instructions?: string;\n};\n\nexport type Transport = {\n  /** Called by the server when it has a message to deliver to the client. */\n  send: (message: JsonRpcMessage) => void;\n  /** Called by the server when it's torn down so the transport can clean up. */\n  close?: () => void;\n};\n\n/**\n * MicroMcpServer — protocol-level MCP server, transport-agnostic.\n *\n * Use it like:\n *\n *   const server = new MicroMcpServer({ info: { name: \"session\", version: \"0.1\" } });\n *   server.registerTool({ name: \"...\", inputSchema: { type: \"object\" } }, async (args) => ({...}));\n *   const transport = new InProcessTransport();\n *   server.attach(transport);\n *   transport.deliver({ ... }); // client → server frames\n *\n * The same server can serve multiple transports (e.g. an in-process agent\n * AND a relayed external client) by attaching each one.\n */\nexport class MicroMcpServer extends ToolRegistry {\n  private transports = new Set<Transport>();\n  private notifyListChangedScheduled = false;\n\n  readonly info: ServerInfo;\n  readonly capabilities: ServerCapabilities;\n  readonly instructions?: string;\n\n  constructor(options: McpServerOptions) {\n    super();\n    this.info = options.info;\n    this.capabilities = options.capabilities ?? { tools: { listChanged: true } };\n    this.instructions = options.instructions;\n  }\n\n  attach(transport: Transport): () => void {\n    this.transports.add(transport);\n    return () => this.detach(transport);\n  }\n\n  detach(transport: Transport): void {\n    if (this.transports.delete(transport)) {\n      transport.close?.();\n    }\n  }\n\n  unregisterTool(name: string): void {\n    if (this.tools.delete(name)) {\n      this.scheduleListChangedNotification();\n    }\n  }\n\n  protected onToolsChanged(): void {\n    this.scheduleListChangedNotification();\n  }\n\n  /**\n   * Receive a JSON-RPC frame from a client (called by the transport).\n   * The transport is responsible for sending the response back.\n   */\n  async receive(transport: Transport, message: JsonRpcMessage): Promise<void> {\n    if (!(\"method\" in message)) return; // It's a response, not a request — ignore.\n\n    const isNotification = !(\"id\" in message);\n    if (isNotification) {\n      // Notifications are fire-and-forget. We ignore unknown methods.\n      return;\n    }\n\n    const request = message as JsonRpcRequest;\n    try {\n      const result = await this.handle(request);\n      transport.send({ jsonrpc: \"2.0\", id: request.id, result });\n    } catch (err) {\n      transport.send({\n        jsonrpc: \"2.0\",\n        id: request.id,\n        error: this.toRpcError(err),\n      });\n    }\n  }\n\n  private async handle(request: JsonRpcRequest): Promise<any> {\n    const { method, params } = request;\n    switch (method) {\n      case \"initialize\":\n        return {\n          protocolVersion: MCP_PROTOCOL_VERSION,\n          capabilities: this.capabilities,\n          serverInfo: this.info,\n          ...(this.instructions ? { instructions: this.instructions } : {}),\n        };\n\n      case \"tools/list\":\n        return { tools: this.listTools() };\n\n      case \"tools/call\": {\n        const name = params?.name;\n        const args = (params?.arguments ?? {}) as JsonObject;\n        if (typeof name !== \"string\") {\n          throw rpcError(JSONRPC_INVALID_PARAMS, \"tools/call requires `name`\");\n        }\n        const tool = this.tools.get(name);\n        if (!tool) {\n          throw rpcError(JSONRPC_METHOD_NOT_FOUND, `Unknown tool: ${name}`);\n        }\n        const result = await tool.handler(args);\n        return result satisfies CallToolResult;\n      }\n\n      case \"ping\":\n        return {};\n\n      default:\n        throw rpcError(JSONRPC_METHOD_NOT_FOUND, `Unsupported method: ${method}`);\n    }\n  }\n\n  private scheduleListChangedNotification(): void {\n    if (this.notifyListChangedScheduled) return;\n    this.notifyListChangedScheduled = true;\n    queueMicrotask(() => {\n      this.notifyListChangedScheduled = false;\n      this.broadcast({ jsonrpc: \"2.0\", method: \"notifications/tools/list_changed\" });\n    });\n  }\n\n  private broadcast(message: JsonRpcMessage): void {\n    for (const t of this.transports) t.send(message);\n  }\n\n  private toRpcError(err: unknown): { code: number; message: string; data?: any } {\n    if (err && typeof err === \"object\" && \"code\" in err && \"message\" in err) {\n      return err as any;\n    }\n    return {\n      code: JSONRPC_INTERNAL_ERROR,\n      message: err instanceof Error ? err.message : String(err),\n    };\n  }\n}\n\nexport function rpcError(code: number, message: string, data?: any) {\n  return { code, message, ...(data !== undefined ? { data } : {}) };\n}\n\n/**\n * Helper to build a CallToolResult from a string or structured value.\n */\nexport function textResult(text: string, structured?: any): CallToolResult {\n  return {\n    content: [{ type: \"text\", text }],\n    ...(structured !== undefined ? { structuredContent: structured } : {}),\n  };\n}\n\nexport function errorResult(text: string): CallToolResult {\n  return { content: [{ type: \"text\", text }], isError: true };\n}\n\n// Internal helper so the JsonRpcId import isn't dropped by tsup\ntype _KeepIdImport = JsonRpcId;\n","import { textResult, errorResult } from \"../mcp/server\";\nimport type { ToolHost } from \"../mcp/tool-host\";\nimport { readHistory, redoOne, undoOne } from \"./undo-stack\";\n\nexport type UndoToolsOptions = {\n  /** Default agent id when the caller doesn't pass one. */\n  defaultAgentId?: string;\n};\n\n/**\n * Idempotent tracker so multiple bridges on the same server only register\n * agent_undo / agent_redo / agent_history once.\n */\nconst installedHosts = new WeakSet<ToolHost>();\n\n/**\n * ensureUndoToolsRegistered — bridges call this on construction. Safe to\n * call repeatedly with the same server; subsequent calls are no-ops.\n */\nexport function ensureUndoToolsRegistered(host: ToolHost, options: UndoToolsOptions = {}): void {\n  if (installedHosts.has(host)) return;\n  installedHosts.add(host);\n  registerUndoTools(host, options);\n}\n\n/**\n * registerUndoTools — add agent_undo / agent_redo / agent_history to the\n * server. Returns a disposer that unregisters all three.\n */\nexport function registerUndoTools(host: ToolHost, options: UndoToolsOptions = {}): () => void {\n  const defaultAgent = options.defaultAgentId ?? \"agent\";\n  const disposers: Array<() => void> = [];\n  const agentOf = (args: any): string =>\n    typeof args?.agentId === \"string\" ? args.agentId : defaultAgent;\n\n  disposers.push(\n    host.registerTool(\n      {\n        name: \"agent_undo\",\n        description: \"Undo the most recent action on the agent's stack. Optional agentId targets a specific agent.\",\n        inputSchema: {\n          type: \"object\",\n          properties: { agentId: { type: \"string\" } },\n          additionalProperties: false,\n        },\n      },\n      async (args) => {\n        const entry = await undoOne(agentOf(args));\n        if (!entry) return errorResult(\"Nothing to undo.\");\n        return textResult(`Undid: ${entry.label}`, { entry: serialize(entry) });\n      },\n    ),\n  );\n\n  disposers.push(\n    host.registerTool(\n      {\n        name: \"agent_redo\",\n        description: \"Redo the most recently undone action.\",\n        inputSchema: {\n          type: \"object\",\n          properties: { agentId: { type: \"string\" } },\n          additionalProperties: false,\n        },\n      },\n      async (args) => {\n        const entry = await redoOne(agentOf(args));\n        if (!entry) return errorResult(\"Nothing to redo.\");\n        return textResult(`Redid: ${entry.label}`, { entry: serialize(entry) });\n      },\n    ),\n  );\n\n  disposers.push(\n    host.registerTool(\n      {\n        name: \"agent_history\",\n        description: \"List the agent's undo stack (oldest first). Useful for understanding what's reversible.\",\n        inputSchema: {\n          type: \"object\",\n          properties: { agentId: { type: \"string\" } },\n          additionalProperties: false,\n        },\n      },\n      async (args) => {\n        const history = readHistory(agentOf(args)).map(serialize);\n        const text = history.map((e) => `${new Date(e.timestamp).toISOString()} ${e.bridgeId} ${e.action}: ${e.label}`).join(\"\\n\");\n        return textResult(text || \"(empty)\", history);\n      },\n    ),\n  );\n\n  return () => disposers.forEach((d) => d());\n}\n\nfunction serialize(entry: import(\"./undo-stack\").UndoEntry) {\n  return {\n    timestamp: entry.timestamp,\n    bridgeId: entry.bridgeId,\n    action: entry.action,\n    label: entry.label,\n  };\n}\n","import { useState, useEffect, useCallback } from \"react\";\nimport { readHistory } from \"./undo-stack\";\n\n/**\n * useUndoStack — minimal React snapshot of an agent's history. Polls every\n * `intervalMs` (default 500). Use this to render an inline \"agent timeline\"\n * in a sidebar or activity panel. No subscription model in v1 — keeping it\n * simple; bridge mutations are infrequent enough that polling is fine.\n */\nexport function useUndoStack(agentId: string, intervalMs = 500) {\n  const [history, setHistory] = useState(() => readHistory(agentId));\n\n  useEffect(() => {\n    let cancelled = false;\n    const tick = () => {\n      if (cancelled) return;\n      setHistory(readHistory(agentId));\n    };\n    const id = setInterval(tick, intervalMs);\n    tick();\n    return () => { cancelled = true; clearInterval(id); };\n  }, [agentId, intervalMs]);\n\n  const refresh = useCallback(() => setHistory(readHistory(agentId)), [agentId]);\n  return { history, refresh };\n}\n"]}

package/dist/undo.js

@@ -0,0 +1,5 @@
+export { useUndoStack } from './chunk-RGO42EQ6.js';
+export { clearStack, ensureUndoToolsRegistered, pushUndoEntry, readHistory, redoOne, registerUndoTools, resetAllUndoStacks, undoOne } from './chunk-GQ7XXK7G.js';
+import './chunk-4KAIV6OD.js';
+//# sourceMappingURL=undo.js.map
+//# sourceMappingURL=undo.js.map

package/dist/undo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"undo.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@particle-academy/agent-integrations",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "description": "MCP-driven agent presence in collab sessions: per-session micro-MCP server, pluggable bridges to fancy-* packages, and agent UX components (panel + on-canvas cursor).",
   "repository": {
     "type": "git",