@particle-academy/agent-integrations 0.2.4 → 0.3.4

package/dist/index.cjs

@@ -4,6 +4,59 @@ var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var fancyWhiteboard = require('@particle-academy/fancy-whiteboard');
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/presence/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  emitActivity: () => emitActivity,
+  onActivity: () => onActivity,
+  readActivityHistory: () => readActivityHistory,
+  resetActivityRegistry: () => resetActivityRegistry
+});
+function emitActivity(event) {
+  history.push(event);
+  if (history.length > HISTORY_CAP) history.splice(0, history.length - HISTORY_CAP);
+  for (const l of listeners) l(event);
+}
+function onActivity(listener, filter) {
+  const wrapped = filter ? (e) => {
+    if (matches(e, filter)) listener(e);
+  } : listener;
+  listeners.add(wrapped);
+  return () => listeners.delete(wrapped);
+}
+function readActivityHistory(filter) {
+  if (!filter) return history.slice();
+  return history.filter((e) => matches(e, filter));
+}
+function resetActivityRegistry() {
+  listeners.clear();
+  history.length = 0;
+}
+function matches(e, f) {
+  if (f.agentId !== void 0 && e.agentId !== f.agentId) return false;
+  if (f.screenId !== void 0 && e.target.screenId !== f.screenId) return false;
+  if (f.kind !== void 0 && e.target.kind !== f.kind) return false;
+  return true;
+}
+var HISTORY_CAP, listeners, history;
+var init_registry = __esm({
+  "src/presence/registry.ts"() {
+    HISTORY_CAP = 200;
+    listeners = /* @__PURE__ */ new Set();
+    history = [];
+  }
+});
+
 // src/mcp/types.ts
 var JSONRPC_METHOD_NOT_FOUND = -32601;
 var JSONRPC_INVALID_PARAMS = -32602;
@@ -194,6 +247,159 @@ function attachRelay(server, channel) {
   return transport;
 }
 
+// src/presence/wrap-tool-with-activity.ts
+init_registry();
+function wrapToolWithActivity(handler, options) {
+  return async (args) => {
+    const result = await handler(args);
+    if (result.isError) return result;
+    let target;
+    if (options.resolveTarget) {
+      target = options.resolveTarget({ toolName: options.toolName, args, result });
+    } else {
+      target = { kind: options.kind, screenId: options.screenId };
+    }
+    if (!target) return result;
+    emitActivity({
+      agentId: options.agent.id,
+      agentName: options.agent.name,
+      agentColor: options.agent.color,
+      target: { ...target, kind: target.kind ?? options.kind, screenId: target.screenId ?? options.screenId },
+      action: options.toolName,
+      timestamp: Date.now(),
+      meta: extractMeta(result),
+      ttlMs: options.ttlMs
+    });
+    return result;
+  };
+}
+function extractMeta(result) {
+  const sc = result.structuredContent;
+  if (sc && typeof sc === "object" && !Array.isArray(sc)) {
+    return sc;
+  }
+  return void 0;
+}
+
+// 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/undo/undo-tools.ts
+var installedServers = /* @__PURE__ */ new WeakSet();
+function ensureUndoToolsRegistered(server, options = {}) {
+  if (installedServers.has(server)) return;
+  installedServers.add(server);
+  registerUndoTools(server, options);
+}
+function registerUndoTools(server, options = {}) {
+  const defaultAgent = options.defaultAgentId ?? "agent";
+  const disposers = [];
+  const agentOf = (args) => typeof args?.agentId === "string" ? args.agentId : defaultAgent;
+  disposers.push(
+    server.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(
+    server.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(
+    server.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 history2 = readHistory(agentOf(args)).map(serialize);
+        const text = history2.map((e) => `${new Date(e.timestamp).toISOString()} ${e.bridgeId} ${e.action}: ${e.label}`).join("\n");
+        return textResult(text || "(empty)", history2);
+      }
+    )
+  );
+  return () => disposers.forEach((d) => d());
+}
+function serialize(entry) {
+  return {
+    timestamp: entry.timestamp,
+    bridgeId: entry.bridgeId,
+    action: entry.action,
+    label: entry.label
+  };
+}
+
 // src/bridges/whiteboard.ts
 var DEFAULT_AGENT = { id: "agent", name: "Agent", color: "#a855f7" };
 var VALID_SHAPES = ["rect", "rounded-rect", "ellipse", "diamond", "triangle", "line", "arrow", "text"];
@@ -205,7 +411,25 @@ function registerWhiteboardBridge(server, options) {
   const { adapter } = options;
   const agent = { ...DEFAULT_AGENT, ...options.agent ?? {} };
   const disposers = [];
-  const reg = (name, description, inputProperties, required, handler) => {
+  ensureUndoToolsRegistered(server, { defaultAgentId: agent.id });
+  const wbTarget = (args, result) => ({
+    kind: "whiteboard",
+    elementId: result?.structuredContent?.id ?? args?.id
+  });
+  const reg = (name, description, inputProperties, required, handler, resolveTarget) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = resolveTarget ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent: { id: agent.id, name: agent.name, color: agent.color },
+      kind: "whiteboard",
+      resolveTarget: ({ args, result }) => resolveTarget(args, result)
+    }) : wrapped;
     disposers.push(
       server.registerTool(
         {
@@ -218,13 +442,7 @@ function registerWhiteboardBridge(server, options) {
             additionalProperties: false
           }
         },
-        async (args) => {
-          try {
-            return await handler(args);
-          } catch (e) {
-            return errorResult(e instanceof Error ? e.message : String(e));
-          }
-        }
+        final
       )
     );
   };
@@ -301,8 +519,17 @@ function registerWhiteboardBridge(server, options) {
         authorId: agent.id
       };
       adapter.setNotes((all) => [...all, note]);
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "whiteboard",
+        action: "whiteboard_add_sticky",
+        label: `Added sticky ${note.id}`,
+        undo: () => adapter.setNotes((all) => all.filter((n) => n.id !== note.id)),
+        redo: () => adapter.setNotes((all) => [...all, note])
+      });
       return textResult(`Added sticky ${note.id}`, note);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_stream_text",
@@ -369,7 +596,8 @@ function registerWhiteboardBridge(server, options) {
         })
       );
       return textResult(`Updated sticky ${id}`, updated);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_add_shape",
@@ -410,7 +638,8 @@ function registerWhiteboardBridge(server, options) {
       };
       adapter.setShapes((all) => [...all, shape]);
       return textResult(`Added ${kind} ${shape.id}`, shape);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_update_shape",
@@ -452,7 +681,8 @@ function registerWhiteboardBridge(server, options) {
         })
       );
       return textResult(`Updated shape ${id}`, updated);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_add_connector",
@@ -473,7 +703,8 @@ function registerWhiteboardBridge(server, options) {
       };
       adapter.setConnectors((all) => [...all, c]);
       return textResult(`Added connector ${c.id}`, c);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_add_stroke",
@@ -502,7 +733,8 @@ function registerWhiteboardBridge(server, options) {
       };
       adapter.setStrokes((all) => [...all, stroke]);
       return textResult(`Added stroke ${stroke.id} (${points.length} points)`, stroke);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_delete_item",
@@ -511,29 +743,37 @@ function registerWhiteboardBridge(server, options) {
     ["id"],
     (args) => {
       const id = str(args.id);
-      let removed = false;
-      adapter.setNotes((all) => {
-        const next = all.filter((x) => x.id !== id);
-        if (next.length !== all.length) removed = true;
-        return next;
-      });
-      adapter.setShapes((all) => {
-        const next = all.filter((x) => x.id !== id);
-        if (next.length !== all.length) removed = true;
-        return next;
-      });
-      adapter.setConnectors((all) => {
-        const next = all.filter((x) => x.id !== id);
-        if (next.length !== all.length) removed = true;
-        return next;
-      });
-      adapter.setStrokes((all) => {
-        const next = all.filter((x) => x.id !== id);
-        if (next.length !== all.length) removed = true;
-        return next;
+      const removedNotes = adapter.getNotes().filter((x) => x.id === id);
+      const removedShapes = adapter.getShapes().filter((x) => x.id === id);
+      const removedConnectors = adapter.getConnectors().filter((x) => x.id === id);
+      const removedStrokes = adapter.getStrokes().filter((x) => x.id === id);
+      const removed = removedNotes.length + removedShapes.length + removedConnectors.length + removedStrokes.length > 0;
+      if (!removed) return errorResult(`No item with id ${id}`);
+      adapter.setNotes((all) => all.filter((x) => x.id !== id));
+      adapter.setShapes((all) => all.filter((x) => x.id !== id));
+      adapter.setConnectors((all) => all.filter((x) => x.id !== id));
+      adapter.setStrokes((all) => all.filter((x) => x.id !== id));
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "whiteboard",
+        action: "whiteboard_delete_item",
+        label: `Deleted ${id}`,
+        undo: () => {
+          if (removedNotes.length) adapter.setNotes((all) => [...all, ...removedNotes]);
+          if (removedShapes.length) adapter.setShapes((all) => [...all, ...removedShapes]);
+          if (removedConnectors.length) adapter.setConnectors((all) => [...all, ...removedConnectors]);
+          if (removedStrokes.length) adapter.setStrokes((all) => [...all, ...removedStrokes]);
+        },
+        redo: () => {
+          adapter.setNotes((all) => all.filter((x) => x.id !== id));
+          adapter.setShapes((all) => all.filter((x) => x.id !== id));
+          adapter.setConnectors((all) => all.filter((x) => x.id !== id));
+          adapter.setStrokes((all) => all.filter((x) => x.id !== id));
+        }
       });
-      return removed ? textResult(`Deleted ${id}`) : errorResult(`No item with id ${id}`);
-    }
+      return textResult(`Deleted ${id}`);
+    },
+    wbTarget
   );
   reg(
     "whiteboard_set_viewport",
@@ -549,7 +789,8 @@ function registerWhiteboardBridge(server, options) {
       };
       adapter.setViewport(next);
       return textResult(`Viewport \u2192 ${JSON.stringify(next)}`, next);
-    }
+    },
+    wbTarget
   );
   reg(
     "whiteboard_set_agent_cursor",
@@ -575,7 +816,8 @@ function registerWhiteboardBridge(server, options) {
       };
       adapter.setAgentCursor(cursor);
       return textResult(`Cursor \u2192 (${cursor.x}, ${cursor.y})`, cursor);
-    }
+    },
+    wbTarget
   );
   return {
     id: "whiteboard",
@@ -586,14 +828,34 @@ function registerWhiteboardBridge(server, options) {
     }
   };
 }
+
+// src/bridges/flow.ts
+var DEFAULT_AGENT2 = { id: "agent", name: "Agent", color: "#a855f7" };
 var num2 = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : 0;
 var str2 = (v, fallback = "") => typeof v === "string" ? v : fallback;
 var newId2 = (prefix) => `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
 function registerFlowBridge(server, options) {
   const { adapter } = options;
-  ({ ...options.agent ?? {} });
+  const agent = { ...DEFAULT_AGENT2, ...options.agent ?? {} };
   const disposers = [];
-  const reg = (name, description, properties, required, handler) => {
+  const flTarget = (args, result) => ({
+    kind: "flow",
+    elementId: result?.structuredContent?.id ?? args?.id
+  });
+  const reg = (name, description, properties, required, handler, resolveTarget) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = resolveTarget ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent: { id: agent.id, name: agent.name, color: agent.color },
+      kind: "flow",
+      resolveTarget: ({ args, result }) => resolveTarget(args, result)
+    }) : wrapped;
     disposers.push(
       server.registerTool(
         {
@@ -601,13 +863,7 @@ function registerFlowBridge(server, options) {
           description,
           inputSchema: { type: "object", properties, required, additionalProperties: false }
         },
-        async (args) => {
-          try {
-            return await handler(args);
-          } catch (e) {
-            return errorResult(e instanceof Error ? e.message : String(e));
-          }
-        }
+        final
       )
     );
   };
@@ -743,7 +999,8 @@ function registerFlowBridge(server, options) {
       };
       adapter.setNodes((all) => [...all, node]);
       return textResult(`Added ${kindName} ${id} ("${str2(args.label)}")`, node);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_update_node",
@@ -781,7 +1038,8 @@ function registerFlowBridge(server, options) {
       );
       if (!updated) return errorResult(`No node with id ${id}`);
       return textResult(`Updated node ${id}`, updated);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_delete_node",
@@ -796,7 +1054,8 @@ function registerFlowBridge(server, options) {
       adapter.setNodes((all) => all.filter((n) => n.id !== id));
       adapter.setEdges((all) => all.filter((e) => e.source !== id && e.target !== id));
       return textResult(`Deleted node ${id}`);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_connect",
@@ -825,7 +1084,8 @@ function registerFlowBridge(server, options) {
       };
       adapter.setEdges((existing) => [...existing, edge]);
       return textResult(`Connected ${source}${edge.sourceHandle ? `:${edge.sourceHandle}` : ""} \u2192 ${target}${edge.targetHandle ? `:${edge.targetHandle}` : ""}`, edge);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_disconnect",
@@ -839,7 +1099,8 @@ function registerFlowBridge(server, options) {
       }
       adapter.setEdges((all) => all.filter((e) => e.id !== id));
       return textResult(`Disconnected ${id}`);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_set_node_status",
@@ -868,7 +1129,8 @@ function registerFlowBridge(server, options) {
         if (!found) return errorResult(`No node with id ${id}`);
       }
       return textResult(`${id} \u2192 ${status}${text ? ` (${text})` : ""}`);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_run",
@@ -879,7 +1141,8 @@ function registerFlowBridge(server, options) {
       if (!adapter.run) return errorResult("Host did not provide a run handler.");
       const result = await adapter.run();
       return textResult(result.ok ? "Run complete" : `Run failed: ${result.error ?? "unknown"}`, result);
-    }
+    },
+    flTarget
   );
   reg(
     "flow_cancel",
@@ -890,7 +1153,8 @@ function registerFlowBridge(server, options) {
       if (!adapter.cancel) return errorResult("Host did not provide a cancel handler.");
       adapter.cancel();
       return textResult("Run cancelled");
-    }
+    },
+    flTarget
   );
   return {
     id: "flow",
@@ -900,6 +1164,909 @@ function registerFlowBridge(server, options) {
     }
   };
 }
+
+// src/bridges/forms.ts
+var DEFAULT_AGENT3 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerFormBridge(server, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT3, ...options.agent ?? {} };
+  const disposers = [];
+  const formId = adapter.id;
+  const target = (args) => ({
+    kind: "form",
+    screenId: adapter.screenId,
+    elementId: typeof args?.field === "string" ? `${formId}:${args.field}` : formId,
+    label: typeof args?.field === "string" ? `${adapter.title ?? formId} \u2192 ${args.field}` : adapter.title ?? formId
+  });
+  const reg = (name, description, properties, required, handler, isMutation) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = isMutation ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent: { id: agent.id, name: agent.name, color: agent.color },
+      kind: "form",
+      screenId: adapter.screenId,
+      resolveTarget: ({ args }) => target(args)
+    }) : wrapped;
+    disposers.push(
+      server.registerTool(
+        {
+          name,
+          description,
+          inputSchema: { type: "object", properties, required, additionalProperties: false }
+        },
+        final
+      )
+    );
+  };
+  reg(
+    "form_describe",
+    `Describe the form "${formId}" \u2014 fields, types, options, required flags. Call this first to know what's fillable.`,
+    {},
+    [],
+    () => {
+      const fields = adapter.getFields();
+      const text = fields.map((f) => `${f.name}${f.required ? "*" : ""} (${f.type})${f.label ? ` \u2014 ${f.label}` : ""}`).join("\n");
+      return textResult(text || "(no fields)", { id: formId, title: adapter.title, fields });
+    },
+    false
+  );
+  reg(
+    "form_get_value",
+    "Read a single field's current value.",
+    { field: { type: "string" } },
+    ["field"],
+    (args) => {
+      const name = String(args.field ?? "");
+      if (!adapter.getFields().find((f) => f.name === name)) {
+        return errorResult(`Unknown field: ${name}`);
+      }
+      const value = adapter.getValue(name);
+      return textResult(JSON.stringify(value), { field: name, value });
+    },
+    false
+  );
+  reg(
+    "form_get_values",
+    "Read every field's current value as a JSON object.",
+    {},
+    [],
+    () => {
+      const values = adapter.getValues();
+      return textResult(JSON.stringify(values, null, 2), values);
+    },
+    false
+  );
+  reg(
+    "form_set_value",
+    "Set one field's value. The host's controlled state updates and the human sees the field change.",
+    {
+      field: { type: "string" },
+      value: { description: "Value to set. Type depends on the field's `type`." }
+    },
+    ["field", "value"],
+    (args) => {
+      const name = String(args.field ?? "");
+      const fieldDef = adapter.getFields().find((f) => f.name === name);
+      if (!fieldDef) return errorResult(`Unknown field: ${name}`);
+      adapter.setValue(name, args.value);
+      return textResult(`${name} \u2190 ${JSON.stringify(args.value)}`, { field: name, value: args.value });
+    },
+    true
+  );
+  reg(
+    "form_set_values",
+    "Set multiple fields atomically. Pass a `values` object keyed by field name.",
+    { values: { type: "object" } },
+    ["values"],
+    (args) => {
+      const values = args.values && typeof args.values === "object" ? args.values : {};
+      const fields = adapter.getFields();
+      const known = new Set(fields.map((f) => f.name));
+      const unknownKeys = Object.keys(values).filter((k) => !known.has(k));
+      if (unknownKeys.length) return errorResult(`Unknown fields: ${unknownKeys.join(", ")}`);
+      if (adapter.setValues) {
+        adapter.setValues(values);
+      } else {
+        for (const [k, v] of Object.entries(values)) adapter.setValue(k, v);
+      }
+      return textResult(`Set ${Object.keys(values).length} field(s)`, { values });
+    },
+    true
+  );
+  reg(
+    "form_focus",
+    "Move browser focus to a field (host-implemented). Useful before streaming text into it.",
+    { field: { type: "string" } },
+    ["field"],
+    (args) => {
+      const name = String(args.field ?? "");
+      if (!adapter.focus) return errorResult("Host did not provide a focus implementation.");
+      if (!adapter.getFields().find((f) => f.name === name)) {
+        return errorResult(`Unknown field: ${name}`);
+      }
+      adapter.focus(name);
+      return textResult(`Focused ${name}`, { field: name });
+    },
+    true
+  );
+  reg(
+    "form_submit",
+    "Submit the form. Host returns ok + values (or an error).",
+    {},
+    [],
+    async () => {
+      if (!adapter.submit) return errorResult("Host did not provide a submit implementation.");
+      const result = await adapter.submit();
+      if (!result.ok) return errorResult(result.error ?? "Submit failed");
+      return textResult("Submitted", { values: result.values });
+    },
+    true
+  );
+  return {
+    id: `form:${formId}`,
+    title: adapter.title ?? formId,
+    dispose: () => {
+      for (const d of disposers) d();
+    }
+  };
+}
+
+// src/bridges/sheets.ts
+var DEFAULT_AGENT4 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerSheetsBridge(server, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT4, ...options.agent ?? {} };
+  const disposers = [];
+  const target = (sheetId, address) => ({
+    kind: "sheet",
+    screenId: adapter.screenId,
+    elementId: address ? `${sheetId}!${address}` : sheetId,
+    label: address ? `${sheetId}!${address}` : sheetId
+  });
+  const reg = (name, description, properties, required, handler, isMutation, resolveTarget) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = isMutation ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent,
+      kind: "sheet",
+      screenId: adapter.screenId,
+      resolveTarget: ({ args, result }) => resolveTarget?.(args, result) ?? target(getSheetId(args))
+    }) : wrapped;
+    disposers.push(
+      server.registerTool(
+        {
+          name,
+          description,
+          inputSchema: { type: "object", properties, required, additionalProperties: false }
+        },
+        final
+      )
+    );
+  };
+  function activeSheetId() {
+    return adapter.getWorkbook().activeSheetId;
+  }
+  function getSheetId(args) {
+    return typeof args.sheet === "string" ? args.sheet : activeSheetId();
+  }
+  function getSheet(workbook, sheetId) {
+    return workbook.sheets.find((s) => s.id === sheetId);
+  }
+  reg(
+    "sheet_describe",
+    "Describe the workbook: every sheet's id, name, dimensions, cell count, active sheet. Call before reading or writing.",
+    {},
+    [],
+    () => {
+      const wb = adapter.getWorkbook();
+      const summary = {
+        activeSheetId: wb.activeSheetId,
+        sheets: wb.sheets.map((s) => ({
+          id: s.id,
+          name: s.name,
+          cellCount: Object.keys(s.cells).length,
+          columnCount: Object.keys(s.columnWidths).length,
+          frozenRows: s.frozenRows,
+          frozenCols: s.frozenCols
+        }))
+      };
+      const text = `Active: ${summary.activeSheetId}
+` + summary.sheets.map((s) => `${s.id} "${s.name}" \u2014 ${s.cellCount} cells`).join("\n");
+      return textResult(text, summary);
+    },
+    false
+  );
+  reg(
+    "sheet_get_cell",
+    "Read a single cell's raw + computed value.",
+    {
+      sheet: { type: "string", description: "Sheet id (defaults to active)." },
+      address: { type: "string", description: 'A1-style address, e.g. "B12".' }
+    },
+    ["address"],
+    (args) => {
+      const sheetId = getSheetId(args);
+      const address = String(args.address);
+      const sheet = getSheet(adapter.getWorkbook(), sheetId);
+      if (!sheet) return errorResult(`No sheet ${sheetId}`);
+      const cell = sheet.cells[address];
+      if (!cell) {
+        return textResult(`(empty)`, { sheet: sheetId, address, value: null });
+      }
+      return textResult(`${address} = ${JSON.stringify(cell.computedValue ?? cell.value)}`, { ...cell, sheet: sheetId, address });
+    },
+    false
+  );
+  reg(
+    "sheet_get_range",
+    "Read a rectangular range as a 2D array of values.",
+    {
+      sheet: { type: "string" },
+      start: { type: "string", description: "Top-left A1 address." },
+      end: { type: "string", description: "Bottom-right A1 address." }
+    },
+    ["start", "end"],
+    (args) => {
+      const sheetId = getSheetId(args);
+      const sheet = getSheet(adapter.getWorkbook(), sheetId);
+      if (!sheet) return errorResult(`No sheet ${sheetId}`);
+      const grid = readRange(sheet, String(args.start), String(args.end));
+      return textResult(JSON.stringify(grid), { sheet: sheetId, start: args.start, end: args.end, values: grid });
+    },
+    false
+  );
+  reg(
+    "sheet_set_cell",
+    "Set a single cell's value. To set a formula, pass a string starting with '='.",
+    {
+      sheet: { type: "string" },
+      address: { type: "string" },
+      value: { description: "string | number | boolean | null. Strings starting with '=' are stored as formulas." }
+    },
+    ["address", "value"],
+    (args) => {
+      const sheetId = getSheetId(args);
+      const address = String(args.address);
+      const value = args.value;
+      const wb = adapter.getWorkbook();
+      const sheet = getSheet(wb, sheetId);
+      if (!sheet) return errorResult(`No sheet ${sheetId}`);
+      const next = mergeCells(wb, sheetId, { [address]: cellOf(address, value) });
+      adapter.setWorkbook(next);
+      return textResult(`${sheetId}!${address} \u2190 ${JSON.stringify(value)}`, { sheet: sheetId, address, value });
+    },
+    true,
+    (args) => target(getSheetId(args), String(args.address ?? ""))
+  );
+  reg(
+    "sheet_set_range",
+    'Set many cells atomically. `cells` is an object map of { "A1": value, "B2": value, ... }.',
+    {
+      sheet: { type: "string" },
+      cells: { type: "object" }
+    },
+    ["cells"],
+    (args) => {
+      const sheetId = getSheetId(args);
+      const wb = adapter.getWorkbook();
+      const sheet = getSheet(wb, sheetId);
+      if (!sheet) return errorResult(`No sheet ${sheetId}`);
+      const cells = args.cells && typeof args.cells === "object" ? args.cells : {};
+      const updates = {};
+      for (const [addr, v] of Object.entries(cells)) updates[addr] = cellOf(addr, v);
+      const next = mergeCells(wb, sheetId, updates);
+      adapter.setWorkbook(next);
+      return textResult(`Set ${Object.keys(cells).length} cells in ${sheetId}`, { sheet: sheetId, count: Object.keys(cells).length });
+    },
+    true
+  );
+  reg(
+    "sheet_add_sheet",
+    "Add a new sheet (tab) to the workbook.",
+    { id: { type: "string" }, name: { type: "string" } },
+    ["id", "name"],
+    (args) => {
+      const wb = adapter.getWorkbook();
+      const id = String(args.id);
+      const name = String(args.name);
+      if (wb.sheets.find((s) => s.id === id)) return errorResult(`Sheet ${id} already exists`);
+      const next = {
+        ...wb,
+        sheets: [
+          ...wb.sheets,
+          {
+            id,
+            name,
+            cells: {},
+            columnWidths: {},
+            mergedRegions: [],
+            columnFilters: {},
+            frozenRows: 0,
+            frozenCols: 0
+          }
+        ]
+      };
+      adapter.setWorkbook(next);
+      return textResult(`Added sheet ${id} ("${name}")`, { id, name });
+    },
+    true,
+    (args) => target(String(args.id ?? ""))
+  );
+  reg(
+    "sheet_set_active",
+    "Switch to a different sheet tab.",
+    { sheet: { type: "string" } },
+    ["sheet"],
+    (args) => {
+      const sheetId = String(args.sheet);
+      const wb = adapter.getWorkbook();
+      if (!getSheet(wb, sheetId)) return errorResult(`No sheet ${sheetId}`);
+      adapter.setWorkbook({ ...wb, activeSheetId: sheetId });
+      return textResult(`Active sheet \u2192 ${sheetId}`, { sheet: sheetId });
+    },
+    true
+  );
+  reg(
+    "sheet_set_active_cell",
+    "Move the active cell selection (host implements DOM focus + scroll).",
+    { sheet: { type: "string" }, address: { type: "string" } },
+    ["address"],
+    (args) => {
+      if (!adapter.setActiveCell) return errorResult("Host did not provide setActiveCell.");
+      const sheetId = getSheetId(args);
+      adapter.setActiveCell(sheetId, String(args.address));
+      return textResult(`Active cell \u2192 ${sheetId}!${args.address}`, { sheet: sheetId, address: args.address });
+    },
+    true,
+    (args) => target(getSheetId(args), String(args.address ?? ""))
+  );
+  return {
+    id: "sheets",
+    title: "Sheets",
+    dispose: () => {
+      for (const d of disposers) d();
+    }
+  };
+}
+function cellOf(address, value) {
+  return { address, value };
+}
+function mergeCells(wb, sheetId, updates) {
+  return {
+    ...wb,
+    sheets: wb.sheets.map(
+      (s) => s.id !== sheetId ? s : { ...s, cells: { ...s.cells, ...updates } }
+    )
+  };
+}
+function parseAddress(addr) {
+  const m = /^([A-Za-z]+)(\d+)$/.exec(addr.trim());
+  if (!m) throw new Error(`Bad address: ${addr}`);
+  const letters = m[1].toUpperCase();
+  let col = 0;
+  for (let i = 0; i < letters.length; i++) {
+    col = col * 26 + (letters.charCodeAt(i) - 64);
+  }
+  return { col: col - 1, row: parseInt(m[2], 10) - 1 };
+}
+function colToLetter(col) {
+  let s = "";
+  let n = col + 1;
+  while (n > 0) {
+    const r = (n - 1) % 26;
+    s = String.fromCharCode(65 + r) + s;
+    n = Math.floor((n - 1) / 26);
+  }
+  return s;
+}
+function readRange(sheet, startAddr, endAddr) {
+  const start = parseAddress(startAddr);
+  const end = parseAddress(endAddr);
+  const r0 = Math.min(start.row, end.row);
+  const r1 = Math.max(start.row, end.row);
+  const c0 = Math.min(start.col, end.col);
+  const c1 = Math.max(start.col, end.col);
+  const grid = [];
+  for (let r = r0; r <= r1; r++) {
+    const row = [];
+    for (let c = c0; c <= c1; c++) {
+      const addr = `${colToLetter(c)}${r + 1}`;
+      const cell = sheet.cells[addr];
+      row.push(cell?.computedValue ?? cell?.value ?? null);
+    }
+    grid.push(row);
+  }
+  return grid;
+}
+
+// src/bridges/code.ts
+var DEFAULT_AGENT5 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerCodeBridge(server, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT5, ...options.agent ?? {} };
+  const disposers = [];
+  const target = {
+    kind: "code",
+    screenId: adapter.screenId,
+    elementId: adapter.id,
+    label: adapter.title ?? adapter.id
+  };
+  const reg = (name, description, properties, required, handler, isMutation) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = isMutation ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent,
+      kind: "code",
+      screenId: adapter.screenId,
+      resolveTarget: () => target
+    }) : wrapped;
+    disposers.push(
+      server.registerTool(
+        {
+          name,
+          description,
+          inputSchema: { type: "object", properties, required, additionalProperties: false }
+        },
+        final
+      )
+    );
+  };
+  reg(
+    "code_describe",
+    `Describe the editor "${adapter.id}" \u2014 language + length + has-selection.`,
+    {},
+    [],
+    () => {
+      const value = adapter.getValue();
+      const language = adapter.getLanguage?.() ?? "unknown";
+      const summary = { id: adapter.id, language, length: value.length, lines: value.split("\n").length };
+      return textResult(JSON.stringify(summary), summary);
+    },
+    false
+  );
+  reg(
+    "code_get_value",
+    "Read the full document text.",
+    {},
+    [],
+    () => {
+      const value = adapter.getValue();
+      return textResult(value, { value });
+    },
+    false
+  );
+  reg(
+    "code_get_selection",
+    "Read the currently-selected text (empty string if no selection).",
+    {},
+    [],
+    () => {
+      if (!adapter.getSelection) return errorResult("Host did not provide getSelection.");
+      const value = adapter.getSelection();
+      return textResult(value, { value });
+    },
+    false
+  );
+  reg(
+    "code_set_value",
+    "Replace the entire document.",
+    { value: { type: "string" } },
+    ["value"],
+    (args) => {
+      const value = String(args.value ?? "");
+      adapter.setValue(value);
+      return textResult(`Replaced document (${value.length} chars)`, { length: value.length });
+    },
+    true
+  );
+  reg(
+    "code_append",
+    "Append text to the end of the document.",
+    { text: { type: "string" } },
+    ["text"],
+    (args) => {
+      const text = String(args.text ?? "");
+      const next = adapter.getValue() + text;
+      adapter.setValue(next);
+      return textResult(`Appended ${text.length} chars`, { length: next.length });
+    },
+    true
+  );
+  reg(
+    "code_stream_append",
+    "Type characters into the document one at a time so the human can read it forming. Returns when streaming finishes.",
+    {
+      text: { type: "string" },
+      cps: { type: "number", description: "Characters per second. Default 25." }
+    },
+    ["text"],
+    async (args) => {
+      const text = String(args.text ?? "");
+      const cps = Math.max(1, Number(args.cps ?? 25));
+      const interval = Math.max(8, Math.round(1e3 / cps));
+      const start = adapter.getValue();
+      for (let i = 1; i <= text.length; i++) {
+        adapter.setValue(start + text.slice(0, i));
+        if (i < text.length) await new Promise((r) => setTimeout(r, interval));
+      }
+      return textResult(`Streamed ${text.length} chars`, { length: text.length });
+    },
+    true
+  );
+  reg(
+    "code_replace_selection",
+    "Replace the currently-selected text with the supplied text.",
+    { text: { type: "string" } },
+    ["text"],
+    (args) => {
+      if (!adapter.replaceSelection) return errorResult("Host did not provide replaceSelection.");
+      adapter.replaceSelection(String(args.text ?? ""));
+      return textResult("Selection replaced", {});
+    },
+    true
+  );
+  reg(
+    "code_set_language",
+    "Switch the active syntax highlighting / formatter.",
+    { language: { type: "string", description: "e.g. 'javascript', 'php', 'sql'." } },
+    ["language"],
+    (args) => {
+      if (!adapter.setLanguage) return errorResult("Host did not provide setLanguage.");
+      const lang = String(args.language ?? "");
+      adapter.setLanguage(lang);
+      return textResult(`Language \u2192 ${lang}`, { language: lang });
+    },
+    true
+  );
+  reg(
+    "code_focus",
+    "Move browser focus to the editor.",
+    {},
+    [],
+    () => {
+      if (!adapter.focus) return errorResult("Host did not provide focus.");
+      adapter.focus();
+      return textResult("Focused", {});
+    },
+    true
+  );
+  return {
+    id: `code:${adapter.id}`,
+    title: adapter.title ?? adapter.id,
+    dispose: () => {
+      for (const d of disposers) d();
+    }
+  };
+}
+
+// src/bridges/charts.ts
+var DEFAULT_AGENT6 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerChartsBridge(server, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT6, ...options.agent ?? {} };
+  const disposers = [];
+  const target = {
+    kind: "chart",
+    screenId: adapter.screenId,
+    elementId: adapter.id,
+    label: adapter.title ?? adapter.id
+  };
+  const reg = (name, description, properties, required, handler, isMutation) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = isMutation ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent,
+      kind: "chart",
+      screenId: adapter.screenId,
+      resolveTarget: () => target
+    }) : wrapped;
+    disposers.push(
+      server.registerTool(
+        { name, description, inputSchema: { type: "object", properties, required, additionalProperties: false } },
+        final
+      )
+    );
+  };
+  reg(
+    "chart_describe",
+    `Describe the chart "${adapter.id}" \u2014 series count, type guesses, axis info.`,
+    {},
+    [],
+    () => {
+      const opt = adapter.getOption();
+      const series = Array.isArray(opt.series) ? opt.series : [];
+      const summary = {
+        id: adapter.id,
+        title: adapter.title,
+        seriesCount: series.length,
+        seriesTypes: series.map((s) => s?.type ?? "unknown"),
+        hasXAxis: !!opt.xAxis,
+        hasYAxis: !!opt.yAxis
+      };
+      return textResult(JSON.stringify(summary), summary);
+    },
+    false
+  );
+  reg(
+    "chart_get_option",
+    "Read the full ECharts option object the chart is rendering.",
+    {},
+    [],
+    () => {
+      const opt = adapter.getOption();
+      return textResult(JSON.stringify(opt, null, 2), opt);
+    },
+    false
+  );
+  reg(
+    "chart_set_option",
+    "Replace the entire ECharts option. Use chart_update_option for partial updates.",
+    { option: { type: "object" } },
+    ["option"],
+    (args) => {
+      const opt = args.option && typeof args.option === "object" ? args.option : {};
+      adapter.setOption(opt);
+      return textResult("Replaced chart option", {});
+    },
+    true
+  );
+  reg(
+    "chart_update_option",
+    "Shallow-merge a partial option update \u2014 only the keys you provide change.",
+    { partial: { type: "object" } },
+    ["partial"],
+    (args) => {
+      const partial = args.partial && typeof args.partial === "object" ? args.partial : {};
+      if (adapter.updateOption) {
+        adapter.updateOption(partial);
+      } else {
+        adapter.setOption({ ...adapter.getOption(), ...partial });
+      }
+      return textResult("Merged chart option", { keys: Object.keys(partial) });
+    },
+    true
+  );
+  reg(
+    "chart_update_data",
+    "Update only the data (typically the `series` field). Leaves layout / axes / colors alone.",
+    { data: { description: "New series array (or whatever shape the host's adapter expects)." } },
+    ["data"],
+    (args) => {
+      if (!adapter.updateData) return errorResult("Host did not provide updateData.");
+      adapter.updateData(args.data);
+      return textResult("Updated chart data", {});
+    },
+    true
+  );
+  return {
+    id: `chart:${adapter.id}`,
+    title: adapter.title ?? adapter.id,
+    dispose: () => {
+      for (const d of disposers) d();
+    }
+  };
+}
+
+// src/bridges/scene.ts
+var DEFAULT_AGENT7 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerSceneBridge(server, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT7, ...options.agent ?? {} };
+  const disposers = [];
+  const target = (objectId) => ({
+    kind: "scene",
+    screenId: adapter.screenId,
+    elementId: objectId ? `${adapter.id}:${objectId}` : adapter.id,
+    label: objectId ? `${adapter.title ?? adapter.id} \u2192 ${objectId}` : adapter.title ?? adapter.id
+  });
+  const reg = (name, description, properties, required, handler, isMutation, objectIdFromArgs) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = isMutation ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent,
+      kind: "scene",
+      screenId: adapter.screenId,
+      resolveTarget: ({ args }) => target(objectIdFromArgs?.(args))
+    }) : wrapped;
+    disposers.push(
+      server.registerTool(
+        { name, description, inputSchema: { type: "object", properties, required, additionalProperties: false } },
+        final
+      )
+    );
+  };
+  const newId3 = (kind) => `${kind}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  reg(
+    "scene_describe",
+    "Describe the scene \u2014 object count, kinds, camera position.",
+    {},
+    [],
+    () => {
+      const scene = adapter.getScene();
+      const summary = {
+        id: adapter.id,
+        objectCount: scene.objects.length,
+        kinds: scene.objects.map((o) => o.kind),
+        camera: scene.camera,
+        background: scene.background
+      };
+      return textResult(JSON.stringify(summary, null, 2), summary);
+    },
+    false
+  );
+  reg(
+    "scene_get_state",
+    "Read the full SceneState (objects + camera + background).",
+    {},
+    [],
+    () => {
+      const scene = adapter.getScene();
+      return textResult(JSON.stringify(scene, null, 2), scene);
+    },
+    false
+  );
+  reg(
+    "scene_add_object",
+    "Add an object to the scene root. Returns the new object's id.",
+    {
+      kind: { type: "string", description: "box | sphere | cylinder | plane | screen | group | custom kind" },
+      position: { type: "array", description: "[x, y, z]" },
+      rotation: { type: "array", description: "[x, y, z] euler" },
+      scale: { type: "array", description: "[x, y, z]" },
+      color: { type: "string" },
+      props: { type: "object", description: "Per-kind config." }
+    },
+    ["kind"],
+    (args) => {
+      const obj = {
+        id: newId3(String(args.kind)),
+        kind: String(args.kind),
+        position: parseTriple(args.position),
+        rotation: parseTriple(args.rotation),
+        scale: parseTriple(args.scale),
+        color: typeof args.color === "string" ? args.color : void 0,
+        props: args.props && typeof args.props === "object" ? args.props : void 0
+      };
+      const scene = adapter.getScene();
+      adapter.setScene({ ...scene, objects: [...scene.objects, obj] });
+      return textResult(`Added ${obj.kind} ${obj.id}`, obj);
+    },
+    true,
+    (args) => void 0
+    // id resolved from result.structuredContent.id
+  );
+  reg(
+    "scene_update_object",
+    "Update fields on an object. Only provided fields change.",
+    {
+      id: { type: "string" },
+      position: { type: "array" },
+      rotation: { type: "array" },
+      scale: { type: "array" },
+      color: { type: "string" },
+      props: { type: "object" }
+    },
+    ["id"],
+    (args) => {
+      const id = String(args.id);
+      const scene = adapter.getScene();
+      const idx = scene.objects.findIndex((o) => o.id === id);
+      if (idx === -1) return errorResult(`No object ${id}`);
+      const orig = scene.objects[idx];
+      const next = {
+        ...orig,
+        ...args.position !== void 0 ? { position: parseTriple(args.position) } : {},
+        ...args.rotation !== void 0 ? { rotation: parseTriple(args.rotation) } : {},
+        ...args.scale !== void 0 ? { scale: parseTriple(args.scale) } : {},
+        ...args.color !== void 0 ? { color: String(args.color) } : {},
+        ...args.props && typeof args.props === "object" ? { props: { ...orig.props ?? {}, ...args.props } } : {}
+      };
+      const objects = [...scene.objects];
+      objects[idx] = next;
+      adapter.setScene({ ...scene, objects });
+      return textResult(`Updated ${id}`, next);
+    },
+    true,
+    (args) => String(args.id ?? "")
+  );
+  reg(
+    "scene_delete_object",
+    "Remove an object from the scene root.",
+    { id: { type: "string" } },
+    ["id"],
+    (args) => {
+      const id = String(args.id);
+      const scene = adapter.getScene();
+      const next = scene.objects.filter((o) => o.id !== id);
+      if (next.length === scene.objects.length) return errorResult(`No object ${id}`);
+      adapter.setScene({ ...scene, objects: next });
+      return textResult(`Deleted ${id}`);
+    },
+    true,
+    (args) => String(args.id ?? "")
+  );
+  reg(
+    "scene_set_camera",
+    "Move the camera. Pass any subset of position/target/fov.",
+    {
+      position: { type: "array", description: "[x, y, z]" },
+      target: { type: "array", description: "[x, y, z] look-at point" },
+      fov: { type: "number" }
+    },
+    [],
+    (args) => {
+      const scene = adapter.getScene();
+      const next = {
+        ...scene.camera ?? {},
+        ...args.position !== void 0 ? { position: parseTriple(args.position) } : {},
+        ...args.target !== void 0 ? { target: parseTriple(args.target) } : {},
+        ...args.fov !== void 0 ? { fov: Number(args.fov) } : {}
+      };
+      if (adapter.setCamera) {
+        adapter.setCamera(next);
+      } else {
+        adapter.setScene({ ...scene, camera: next });
+      }
+      return textResult(`Camera updated`, next);
+    },
+    true
+  );
+  reg(
+    "scene_set_background",
+    "Change the scene background color (CSS color).",
+    { color: { type: "string" } },
+    ["color"],
+    (args) => {
+      const scene = adapter.getScene();
+      adapter.setScene({ ...scene, background: String(args.color) });
+      return textResult(`Background \u2192 ${args.color}`, { background: args.color });
+    },
+    true
+  );
+  return {
+    id: `scene:${adapter.id}`,
+    title: adapter.title ?? adapter.id,
+    dispose: () => {
+      for (const d of disposers) d();
+    }
+  };
+}
+function parseTriple(v) {
+  if (!Array.isArray(v) || v.length !== 3) return void 0;
+  const out = v.map((x) => Number(x));
+  if (out.some((x) => !Number.isFinite(x))) return void 0;
+  return out;
+}
 function AgentPanel({ agent, activity, onSubmit, busy, actions, className, style }) {
   const scrollRef = react.useRef(null);
   const inputRef = react.useRef(null);
@@ -1063,6 +2230,101 @@ function AgentActivityHighlight({
     }
   );
 }
+function BridgedForm({
+  id,
+  title,
+  screenId,
+  fields,
+  values,
+  onChange,
+  onSubmit,
+  server,
+  agent,
+  children
+}) {
+  const valuesRef = react.useRef(values);
+  const onChangeRef = react.useRef(onChange);
+  const fieldsRef = react.useRef(fields);
+  const submitRef = react.useRef(onSubmit);
+  react.useEffect(() => {
+    valuesRef.current = values;
+  }, [values]);
+  react.useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  react.useEffect(() => {
+    fieldsRef.current = fields;
+  }, [fields]);
+  react.useEffect(() => {
+    submitRef.current = onSubmit;
+  }, [onSubmit]);
+  const focusElement = (name) => {
+    if (typeof document === "undefined") return;
+    const el = document.querySelector(`[data-form-id="${id}"] [name="${name}"]`);
+    el?.focus();
+  };
+  const adapter = react.useMemo(() => ({
+    id,
+    title,
+    screenId,
+    getFields: () => fieldsRef.current,
+    getValue: (name) => valuesRef.current[name],
+    getValues: () => ({ ...valuesRef.current }),
+    setValue: (name, v) => onChangeRef.current({ ...valuesRef.current, [name]: v }),
+    setValues: (next) => onChangeRef.current({ ...valuesRef.current, ...next }),
+    focus: focusElement,
+    submit: async () => {
+      if (!submitRef.current) {
+        return { ok: true, values: { ...valuesRef.current } };
+      }
+      return submitRef.current();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), [id, title, screenId]);
+  react.useEffect(() => {
+    if (!server) return;
+    const bridge = registerFormBridge(server, { adapter, agent });
+    return () => bridge.dispose();
+  }, [server, adapter, agent]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-form-id": id, children });
+}
+
+// src/components/ScreensActivityBridge/ScreensActivityBridge.tsx
+init_registry();
+function ScreensActivityBridge({ system, fadeMs = 1500 }) {
+  react.useEffect(() => {
+    const fadeTimers = /* @__PURE__ */ new Map();
+    const off = onActivity((event) => {
+      const screenId = event.target.screenId;
+      if (!screenId) return;
+      if (!system.registry.has(screenId)) return;
+      const activity = {
+        agentId: event.agentId,
+        agentName: event.agentName,
+        agentColor: event.agentColor,
+        action: event.action,
+        timestamp: event.timestamp,
+        elementId: event.target.elementId,
+        label: event.target.label
+      };
+      system.updateScreen(screenId, { agentActivity: activity });
+      const prev = fadeTimers.get(screenId);
+      if (prev) clearTimeout(prev);
+      fadeTimers.set(
+        screenId,
+        setTimeout(() => {
+          system.updateScreen(screenId, { agentActivity: null });
+          fadeTimers.delete(screenId);
+        }, event.ttlMs ?? fadeMs)
+      );
+    });
+    return () => {
+      off();
+      for (const t of fadeTimers.values()) clearTimeout(t);
+    };
+  }, [system, fadeMs]);
+  return null;
+}
 
 // src/sharing/token.ts
 var TOKEN_BYTES = 24;
@@ -1333,16 +2595,31 @@ function attachSseRelay(server, options) {
   transport.bindServer(server);
   server.attach(transport);
   transport.start();
+  Promise.resolve().then(() => (init_registry(), registry_exports)).then(({ onActivity: onActivity2 }) => {
+    const off = onActivity2((event) => {
+      transport.send({
+        jsonrpc: "2.0",
+        method: "notifications/agent_activity",
+        params: event
+      });
+    });
+    const origClose = transport.close.bind(transport);
+    transport.close = () => {
+      off();
+      origClose();
+    };
+  }).catch(() => {
+  });
   return transport;
 }
-var DEFAULT_AGENT3 = { id: "agent", name: "Agent", color: "#a855f7" };
+var DEFAULT_AGENT8 = { id: "agent", name: "Agent", color: "#a855f7" };
 function SharedWhiteboard({
   initialNotes = [],
   initialShapes = [],
   initialConnectors = [],
   initialStrokes = [],
   initialViewport = { x: 0, y: 0, zoom: 1 },
-  agent = DEFAULT_AGENT3,
+  agent = DEFAULT_AGENT8,
   shareBaseUrl = "/whiteboard-share",
   onRegisterSession,
   showAgentPanel = true,
@@ -1605,13 +2882,69 @@ function resolveCenter(ref, notes, shapes) {
   return ref;
 }
 
+// src/presence/index.ts
+init_registry();
+
+// src/presence/use-agent-activity.ts
+init_registry();
+function useAgentActivity(filter, options = {}) {
+  const cap = options.capacity ?? 50;
+  const [events, setEvents] = react.useState(() => readActivityHistory(filter).slice(-cap));
+  react.useEffect(() => {
+    setEvents(readActivityHistory(filter).slice(-cap));
+    return onActivity((event) => {
+      setEvents((prev) => {
+        const next = prev.length >= cap ? prev.slice(prev.length - cap + 1) : prev.slice();
+        next.push(event);
+        return next;
+      });
+    }, filter);
+  }, [filter?.agentId, filter?.screenId, filter?.kind, cap]);
+  return { events, latest: events.length > 0 ? events[events.length - 1] : null };
+}
+function useAgentActivityForScreen(screenId, options = {}) {
+  const { events, latest } = useAgentActivity({ screenId }, options);
+  const fadeAfter = latest?.ttlMs ?? 1500;
+  const [isAgentActive, setActive] = react.useState(false);
+  react.useEffect(() => {
+    if (!latest) {
+      setActive(false);
+      return;
+    }
+    setActive(true);
+    const timer = setTimeout(() => setActive(false), fadeAfter);
+    return () => clearTimeout(timer);
+  }, [latest, fadeAfter]);
+  return { events, latest, isAgentActive };
+}
+function useUndoStack(agentId, intervalMs = 500) {
+  const [history2, 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: history2, refresh };
+}
+
 exports.AgentActivityHighlight = AgentActivityHighlight;
 exports.AgentCursor = AgentCursor;
 exports.AgentPanel = AgentPanel;
+exports.BridgedForm = BridgedForm;
 exports.InProcessTransport = InProcessTransport;
 exports.MCP_PROTOCOL_VERSION = MCP_PROTOCOL_VERSION;
 exports.MicroMcpServer = MicroMcpServer;
 exports.RelayTransport = RelayTransport;
+exports.ScreensActivityBridge = ScreensActivityBridge;
 exports.ShareControls = ShareControls;
 exports.SharedWhiteboard = SharedWhiteboard;
 exports.SseRelayTransport = SseRelayTransport;
@@ -1620,13 +2953,34 @@ exports.attachRelay = attachRelay;
 exports.attachSseRelay = attachSseRelay;
 exports.buildShareConfig = buildShareConfig;
 exports.buildShareUrl = buildShareUrl;
+exports.clearUndoStack = clearStack;
 exports.createSessionDescriptor = createSessionDescriptor;
 exports.describeSession = describeSession;
+exports.emitActivity = emitActivity;
+exports.ensureUndoToolsRegistered = ensureUndoToolsRegistered;
 exports.errorResult = errorResult;
+exports.onActivity = onActivity;
+exports.pushUndoEntry = pushUndoEntry;
+exports.readActivityHistory = readActivityHistory;
 exports.readSessionFromUrl = readSessionFromUrl;
+exports.readUndoHistory = readHistory;
+exports.redoOne = redoOne;
+exports.registerChartsBridge = registerChartsBridge;
+exports.registerCodeBridge = registerCodeBridge;
 exports.registerFlowBridge = registerFlowBridge;
+exports.registerFormBridge = registerFormBridge;
+exports.registerSceneBridge = registerSceneBridge;
+exports.registerSheetsBridge = registerSheetsBridge;
+exports.registerUndoTools = registerUndoTools;
 exports.registerWhiteboardBridge = registerWhiteboardBridge;
+exports.resetActivityRegistry = resetActivityRegistry;
+exports.resetAllUndoStacks = resetAllUndoStacks;
 exports.rpcError = rpcError;
 exports.textResult = textResult;
+exports.undoOne = undoOne;
+exports.useAgentActivity = useAgentActivity;
+exports.useAgentActivityForScreen = useAgentActivityForScreen;
+exports.useUndoStack = useUndoStack;
+exports.wrapToolWithActivity = wrapToolWithActivity;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map