@nimblebrain/synapse 0.15.0 → 0.17.0

package/dist/{chunk-GNTQJSQX.js → chunk-VYR6V47N.js}

@@ -1,446 +1,66 @@
-import { extractFontFaces, applyTheme, foldFontFaces, detectHost, extractTheme, fontFacesKey } from './chunk-J5ICAHK2.js';
-import { INITIALIZE_METHOD, LATEST_PROTOCOL_VERSION, HOST_CONTEXT_CHANGED_METHOD, INITIALIZED_METHOD, MESSAGE_METHOD, OPEN_LINK_METHOD, TOOL_RESULT_METHOD, RESOURCE_TEARDOWN_METHOD, TOOL_CANCELLED_METHOD, TOOL_INPUT_PARTIAL_METHOD, TOOL_INPUT_METHOD } from '@modelcontextprotocol/ext-apps';
+import { detectHost, foldFontFaces, applyTheme, fontFacesKey, extractTheme } from './chunk-UPDBDXQB.js';
+import { INITIALIZE_METHOD, LATEST_PROTOCOL_VERSION, HOST_CONTEXT_CHANGED_METHOD, INITIALIZED_METHOD, MESSAGE_METHOD, OPEN_LINK_METHOD, RESOURCE_TEARDOWN_METHOD, TOOL_CANCELLED_METHOD, TOOL_INPUT_PARTIAL_METHOD, TOOL_INPUT_METHOD, TOOL_RESULT_METHOD } from '@modelcontextprotocol/ext-apps';
 
-// src/content-parser.ts
-function parseToolResultParams(params) {
-  const raw = params ?? {};
-  const structuredContent = raw.structuredContent ?? null;
-  if (structuredContent != null) {
-    return { content: structuredContent, structuredContent, raw };
-  }
-  const rawContent = raw.content;
-  if (Array.isArray(rawContent)) {
-    const texts = rawContent.filter(
-      (block) => block != null && typeof block === "object" && block.type === "text" && typeof block.text === "string"
-    ).map((block) => block.text);
-    if (texts.length > 0) {
-      const joined = texts.join("");
-      try {
-        return { content: JSON.parse(joined), structuredContent: null, raw };
-      } catch {
-        return { content: joined, structuredContent: null, raw };
-      }
-    }
-    return { content: rawContent, structuredContent: null, raw };
-  }
-  if (typeof rawContent === "string") {
-    try {
-      return { content: JSON.parse(rawContent), structuredContent: null, raw };
-    } catch {
-      return { content: rawContent, structuredContent: null, raw };
-    }
-  }
-  return { content: rawContent ?? null, structuredContent: null, raw };
-}
-var EVENT_MAP = {
-  "tool-result": TOOL_RESULT_METHOD,
-  "tool-input": TOOL_INPUT_METHOD,
-  "tool-input-partial": TOOL_INPUT_PARTIAL_METHOD,
-  "tool-cancelled": TOOL_CANCELLED_METHOD,
-  "theme-changed": HOST_CONTEXT_CHANGED_METHOD,
-  teardown: RESOURCE_TEARDOWN_METHOD
-};
-function resolveEventMethod(name) {
-  return EVENT_MAP[name] ?? name;
-}
-
-// src/resize.ts
-function createResizer(send, autoResize) {
-  let destroyed = false;
-  let observer = null;
-  let rafId = null;
-  function measureAndSend() {
-    if (destroyed) return;
-    const width = document.body.scrollWidth;
-    const height = document.body.scrollHeight;
-    send("ui/notifications/size-changed", { width, height });
-  }
-  function resize(width, height) {
-    if (destroyed) return;
-    if (width !== void 0 && height !== void 0) {
-      send("ui/notifications/size-changed", { width, height });
-    } else {
-      measureAndSend();
-    }
-  }
-  if (autoResize && typeof ResizeObserver !== "undefined") {
-    observer = new ResizeObserver(() => {
-      if (destroyed) return;
-      if (rafId !== null) cancelAnimationFrame(rafId);
-      rafId = requestAnimationFrame(() => {
-        rafId = null;
-        measureAndSend();
-      });
-    });
-    observer.observe(document.body);
-  }
-  function destroy() {
-    if (destroyed) return;
-    destroyed = true;
-    if (rafId !== null) cancelAnimationFrame(rafId);
-    observer?.disconnect();
-    observer = null;
-  }
-  return { resize, measureAndSend, destroy };
-}
-
-// src/result-parser.ts
-function parseToolResult(raw) {
-  if (raw == null) {
-    return { data: null, isError: false };
-  }
-  if (isCallToolResult(raw)) {
-    return parseCallToolResult(raw);
-  }
-  return { data: raw, isError: false };
-}
-function isCallToolResult(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  return Array.isArray(value.content);
-}
-function isTextBlock(block) {
-  if (block === null || typeof block !== "object" || Array.isArray(block)) {
-    return false;
-  }
-  const obj = block;
-  return obj.type === "text" && typeof obj.text === "string";
-}
-function extractMeta(result) {
-  const meta = result._meta;
-  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
-  return { ...meta };
-}
-function parseCallToolResult(result) {
-  const isError = result.isError === true;
-  const content = result.content;
-  const meta = extractMeta(result);
-  if (content.length === 0) {
-    return { data: null, isError, content, ...meta && { _meta: meta } };
-  }
-  const firstText = content.find(isTextBlock);
-  if (!firstText) {
-    return { data: content, isError, content, ...meta && { _meta: meta } };
-  }
-  try {
-    return { data: JSON.parse(firstText.text), isError, content, ...meta && { _meta: meta } };
-  } catch {
-    return { data: firstText.text, isError, content, ...meta && { _meta: meta } };
-  }
-}
-
-// src/transport.ts
-var SynapseTransport = class {
-  counter = 0;
-  destroyed = false;
-  pending = /* @__PURE__ */ new Map();
-  handlers = /* @__PURE__ */ new Map();
-  listener;
-  constructor() {
-    this.listener = (event) => this.handleMessage(event);
-    window.addEventListener("message", this.listener);
-  }
-  send(method, params) {
-    if (this.destroyed) return;
-    const msg = {
-      jsonrpc: "2.0",
-      method,
-      ...params !== void 0 && { params }
-    };
-    window.parent.postMessage(msg, "*");
-  }
-  request(method, params) {
-    if (this.destroyed) {
-      return Promise.reject(new Error("Transport destroyed"));
-    }
-    const id = `syn-${++this.counter}`;
-    const msg = {
-      jsonrpc: "2.0",
-      method,
-      id,
-      ...params !== void 0 && { params }
-    };
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      window.parent.postMessage(msg, "*");
-    });
-  }
-  onMessage(method, callback) {
-    if (!this.handlers.has(method)) {
-      this.handlers.set(method, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(method)?.add(callback);
-    return () => {
-      const set = this.handlers.get(method);
-      if (set) {
-        set.delete(callback);
-        if (set.size === 0) {
-          this.handlers.delete(method);
-        }
-      }
-    };
-  }
-  destroy() {
-    if (this.destroyed) return;
-    this.destroyed = true;
-    window.removeEventListener("message", this.listener);
-    const error = new Error("Transport destroyed");
-    for (const entry of this.pending.values()) {
-      entry.reject(error);
-    }
-    this.pending.clear();
-    this.handlers.clear();
-  }
-  handleMessage(event) {
-    if (this.destroyed) return;
-    const data = event.data;
-    if (!data || data.jsonrpc !== "2.0") return;
-    if ("id" in data && data.id && !("method" in data)) {
-      const response = data;
-      const entry = this.pending.get(response.id);
-      if (!entry) return;
-      this.pending.delete(response.id);
-      if (response.error) {
-        const err = new Error(response.error.message);
-        err.code = response.error.code;
-        err.data = response.error.data;
-        entry.reject(err);
-      } else {
-        entry.resolve(response.result);
-      }
-      return;
-    }
-    if ("method" in data && !("id" in data && data.id)) {
-      const notification = data;
-      const set = this.handlers.get(notification.method);
-      if (set) {
-        for (const handler of set) {
-          handler(notification.params);
-        }
-      }
-    }
-  }
-};
-
-// src/connect.ts
-var READ_RESOURCE_METHOD = "resources/read";
-async function connect(options) {
-  const { name, version, autoResize = false } = options;
-  const transport = new SynapseTransport();
-  let destroyed = false;
-  let currentTheme = { mode: "light", tokens: {} };
-  let hostInfo = { name: "unknown", version: "unknown" };
-  let toolInfo = null;
-  let containerDimensions = null;
-  const handlers = /* @__PURE__ */ new Map();
-  const resizer = createResizer((method, params) => transport.send(method, params), autoResize);
-  resizer.measureAndSend();
-  const initParams = {
-    protocolVersion: LATEST_PROTOCOL_VERSION,
-    appInfo: { name, version },
-    appCapabilities: {}
-  };
-  const result = await transport.request(
-    INITIALIZE_METHOD,
-    initParams
-  );
-  if (result) {
-    hostInfo = {
-      name: result.hostInfo?.name ?? "unknown",
-      version: result.hostInfo?.version ?? "unknown"
-    };
-    const ctx = result.hostContext;
-    if (ctx) {
-      const initialFontFaces = extractFontFaces(ctx);
-      currentTheme = {
-        mode: ctx.theme === "dark" ? "dark" : "light",
-        tokens: ctx.styles?.variables && typeof ctx.styles.variables === "object" ? ctx.styles.variables : {},
-        ...initialFontFaces ? { fontFaces: initialFontFaces } : {}
-      };
-      if (ctx.toolInfo && typeof ctx.toolInfo === "object") {
-        toolInfo = { tool: ctx.toolInfo.tool ?? {} };
-      }
-      if (ctx.containerDimensions && typeof ctx.containerDimensions === "object") {
-        containerDimensions = ctx.containerDimensions;
-      }
-      applyTheme(currentTheme.mode, currentTheme.tokens, currentTheme.fontFaces);
-    }
-  }
-  transport.onMessage(HOST_CONTEXT_CHANGED_METHOD, (params) => {
-    if (destroyed || !params) return;
-    const ctx = params;
-    const mode = ctx.theme === "dark" ? "dark" : "light";
-    const variables = ctx.styles?.variables;
-    const tokens = variables && typeof variables === "object" ? variables : currentTheme.tokens;
-    const fontFaces = foldFontFaces(currentTheme.fontFaces, ctx);
-    currentTheme = { mode, tokens, ...fontFaces ? { fontFaces } : {} };
-    applyTheme(mode, tokens, fontFaces);
-    const set = handlers.get(HOST_CONTEXT_CHANGED_METHOD);
-    if (set) {
-      for (const handler of set) handler(currentTheme);
-    }
-  });
-  const subscribedMethods = /* @__PURE__ */ new Set([HOST_CONTEXT_CHANGED_METHOD]);
-  function ensureTransportSub(method) {
-    if (subscribedMethods.has(method)) return;
-    subscribedMethods.add(method);
-    const isToolResult = method === TOOL_RESULT_METHOD;
-    transport.onMessage(method, (params) => {
-      if (destroyed) return;
-      const set = handlers.get(method);
-      if (!set) return;
-      for (const handler of set) {
-        if (isToolResult) {
-          handler(parseToolResultParams(params));
-        } else {
-          handler(params);
-        }
-      }
-    });
-  }
-  if (options.on) {
-    for (const [event, handler] of Object.entries(options.on)) {
-      if (typeof handler === "function") {
-        const method = resolveEventMethod(event);
-        if (!handlers.has(method)) handlers.set(method, /* @__PURE__ */ new Set());
-        handlers.get(method)?.add(handler);
-        ensureTransportSub(method);
-      }
-    }
-  }
-  transport.send(INITIALIZED_METHOD, {});
-  const app = {
-    get theme() {
-      return { ...currentTheme };
-    },
-    get hostInfo() {
-      return { ...hostInfo };
-    },
-    get toolInfo() {
-      return toolInfo;
-    },
-    get containerDimensions() {
-      return containerDimensions;
-    },
-    on(event, handler) {
-      const method = resolveEventMethod(event);
-      if (!handlers.has(method)) {
-        handlers.set(method, /* @__PURE__ */ new Set());
-      }
-      handlers.get(method)?.add(handler);
-      ensureTransportSub(method);
-      return () => {
-        const set = handlers.get(method);
-        if (set) {
-          set.delete(handler);
-          if (set.size === 0) handlers.delete(method);
-        }
-      };
-    },
-    resize(width, height) {
-      resizer.resize(width, height);
-    },
-    openLink(url) {
-      if (destroyed) return;
-      const params = { url };
-      transport.request(OPEN_LINK_METHOD, params).catch(() => {
-      });
-    },
-    updateModelContext(state, summary) {
-      if (destroyed) return;
-      const params = {
-        structuredContent: state,
-        ...summary !== void 0 && {
-          content: [{ type: "text", text: summary }]
-        }
-      };
-      transport.send("ui/update-model-context", params);
-    },
-    async callTool(toolName, args) {
-      const params = {
-        name: toolName,
-        arguments: args ?? {}
-      };
-      const raw = await transport.request(
-        "tools/call",
-        params
-      );
-      return parseToolResult(raw);
-    },
-    async readServerResource(params) {
-      const raw = await transport.request(
-        READ_RESOURCE_METHOD,
-        params
-      );
-      return raw;
-    },
-    sendMessage(text, context) {
-      if (destroyed) return;
-      const textBlock = {
-        type: "text",
-        text,
-        ...context && { _meta: { context } }
-      };
-      const params = {
-        role: "user",
-        content: [textBlock]
-      };
-      transport.send(MESSAGE_METHOD, params);
-    },
-    destroy() {
-      if (destroyed) return;
-      destroyed = true;
-      resizer.destroy();
-      handlers.clear();
-      transport.destroy();
-    }
-  };
-  return app;
-}
-
-// src/keyboard.ts
-var KeyboardForwarder = class {
-  listener;
-  destroyed = false;
-  constructor(transport, customKeys) {
-    const config = customKeys ?? null;
-    this.listener = (event) => {
-      if (this.destroyed) return;
-      if (this.shouldForward(event, config)) {
-        event.preventDefault();
-        transport.send("synapse/keydown", {
-          key: event.key,
-          ctrlKey: event.ctrlKey,
-          metaKey: event.metaKey,
-          shiftKey: event.shiftKey,
-          altKey: event.altKey
-        });
-      }
-    };
-    document.addEventListener("keydown", this.listener);
+// src/internals.ts
+var INTERNALS = /* @__PURE__ */ new WeakMap();
+function registerInternals(app, internals) {
+  INTERNALS.set(app, internals);
+}
+function internalsFor(app) {
+  const internals = INTERNALS.get(app);
+  if (!internals) {
+    throw new Error(
+      "This App did not come from this copy of @nimblebrain/synapse. Two copies of the package are installed (check for a duplicate in your lockfile, or a bundler resolving the ESM and CJS builds separately)."
+    );
   }
-  destroy() {
-    if (this.destroyed) return;
-    this.destroyed = true;
-    document.removeEventListener("keydown", this.listener);
+  return internals;
+}
+
+// src/result-parser.ts
+function parseToolResult(raw) {
+  if (raw == null) {
+    return { data: null, isError: false };
   }
-  shouldForward(event, config) {
-    if (config && config.length === 0) return false;
-    if (config) {
-      return config.some(
-        (k) => event.key.toLowerCase() === k.key.toLowerCase() && (k.ctrl === void 0 || event.ctrlKey === k.ctrl) && (k.meta === void 0 || event.metaKey === k.meta) && (k.shift === void 0 || event.shiftKey === k.shift) && (k.alt === void 0 || event.altKey === k.alt)
-      );
-    }
-    if (event.key === "Escape") return true;
-    if (event.ctrlKey || event.metaKey) {
-      const key = event.key.toLowerCase();
-      if (key === "c" || key === "v" || key === "x" || key === "a") return false;
-      return true;
-    }
+  if (isCallToolResult(raw)) {
+    return parseCallToolResult(raw);
+  }
+  return { data: raw, isError: false };
+}
+function isCallToolResult(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return false;
   }
-};
+  return Array.isArray(value.content);
+}
+function isTextBlock(block) {
+  if (block === null || typeof block !== "object" || Array.isArray(block)) {
+    return false;
+  }
+  const obj = block;
+  return obj.type === "text" && typeof obj.text === "string";
+}
+function extractMeta(result) {
+  const meta = result._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
+  return { ...meta };
+}
+function parseCallToolResult(result) {
+  const isError = result.isError === true;
+  const content = result.content;
+  const meta = extractMeta(result);
+  if (content.length === 0) {
+    return { data: null, isError, content, ...meta && { _meta: meta } };
+  }
+  const firstText = content.find(isTextBlock);
+  if (!firstText) {
+    return { data: content, isError, content, ...meta && { _meta: meta } };
+  }
+  try {
+    return { data: JSON.parse(firstText.text), isError, content, ...meta && { _meta: meta } };
+  } catch {
+    return { data: firstText.text, isError, content, ...meta && { _meta: meta } };
+  }
+}
 
 // src/task-handle.ts
 var TOOLS_CALL_METHOD = "tools/call";
@@ -485,11 +105,12 @@ function createTaskStatusRouter(transport) {
     }
   };
 }
-async function callToolAsTask(deps, toolName, args, options) {
-  const hostTasks = deps.getHostTasksCapability();
+async function callToolAsTask(app, toolName, args, options) {
+  const deps = internalsFor(app);
+  const hostTasks = deps.hostTasksCapability;
   if (!hostTasks?.requests?.tools?.call) {
     throw new Error(
-      "callToolAsTask: host did not advertise tasks.requests.tools.call in its capabilities. Per MCP 2025-11-25 \xA7, requestors MUST NOT task-augment a tools/call without matching receiver capability. Fall back to `synapse.callTool`."
+      "callToolAsTask: host did not advertise tasks.requests.tools.call in its capabilities. Per MCP 2025-11-25 \xA7, requestors MUST NOT task-augment a tools/call without matching receiver capability. Fall back to `app.callTool`."
     );
   }
   const taskParam = {};
@@ -501,7 +122,7 @@ async function callToolAsTask(deps, toolName, args, options) {
     task: taskParam,
     ...crossServer ? { server: deps.appName } : {}
   };
-  const raw = await deps.transport.request(
+  const raw = await deps.request(
     TOOLS_CALL_METHOD,
     callParams
   );
@@ -518,7 +139,7 @@ async function callToolAsTask(deps, toolName, args, options) {
     task: initialTask,
     async result() {
       const params = { taskId };
-      const rawResult = await deps.transport.request(
+      const rawResult = await deps.request(
         TASKS_RESULT_METHOD,
         params
       );
@@ -527,7 +148,7 @@ async function callToolAsTask(deps, toolName, args, options) {
     },
     async refresh() {
       const params = { taskId };
-      const raw2 = await deps.transport.request(
+      const raw2 = await deps.request(
         TASKS_GET_METHOD,
         params
       );
@@ -535,7 +156,7 @@ async function callToolAsTask(deps, toolName, args, options) {
     },
     async cancel() {
       const params = { taskId };
-      const raw2 = await deps.transport.request(
+      const raw2 = await deps.request(
         TASKS_CANCEL_METHOD,
         params
       );
@@ -544,7 +165,7 @@ async function callToolAsTask(deps, toolName, args, options) {
     onStatus(cb) {
       const existing = localCallbacks.get(cb);
       if (existing) return existing;
-      const wireUnsub = deps.router.subscribe(taskId, (update) => {
+      const wireUnsub = deps.taskRouter.subscribe(taskId, (update) => {
         const merged = {
           taskId: update.taskId,
           status: update.status,
@@ -565,42 +186,269 @@ async function callToolAsTask(deps, toolName, args, options) {
       localCallbacks.set(cb, unsub);
       return unsub;
     }
-  };
-  return handle;
-}
-function projectTask(raw) {
-  return {
-    taskId: raw.taskId,
-    status: raw.status,
-    ttl: raw.ttl,
-    createdAt: raw.createdAt,
-    lastUpdatedAt: raw.lastUpdatedAt,
-    ...raw.pollInterval !== void 0 && { pollInterval: raw.pollInterval },
-    ...raw.statusMessage !== void 0 && { statusMessage: raw.statusMessage }
-  };
-}
+  };
+  return handle;
+}
+function projectTask(raw) {
+  return {
+    taskId: raw.taskId,
+    status: raw.status,
+    ttl: raw.ttl,
+    createdAt: raw.createdAt,
+    lastUpdatedAt: raw.lastUpdatedAt,
+    ...raw.pollInterval !== void 0 && { pollInterval: raw.pollInterval },
+    ...raw.statusMessage !== void 0 && { statusMessage: raw.statusMessage }
+  };
+}
+
+// src/content-parser.ts
+function parseToolResultParams(params) {
+  const raw = params ?? {};
+  const structuredContent = raw.structuredContent ?? null;
+  if (structuredContent != null) {
+    return { content: structuredContent, structuredContent, raw };
+  }
+  const rawContent = raw.content;
+  if (Array.isArray(rawContent)) {
+    const texts = rawContent.filter(
+      (block) => block != null && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text);
+    if (texts.length > 0) {
+      const joined = texts.join("");
+      try {
+        return { content: JSON.parse(joined), structuredContent: null, raw };
+      } catch {
+        return { content: joined, structuredContent: null, raw };
+      }
+    }
+    return { content: rawContent, structuredContent: null, raw };
+  }
+  if (typeof rawContent === "string") {
+    try {
+      return { content: JSON.parse(rawContent), structuredContent: null, raw };
+    } catch {
+      return { content: rawContent, structuredContent: null, raw };
+    }
+  }
+  return { content: rawContent ?? null, structuredContent: null, raw };
+}
+var DATA_CHANGED_METHOD = "synapse/data-changed";
+var ACTION_METHOD = "synapse/action";
+var REQUEST_FILE_METHOD = "synapse/request-file";
+var DOWNLOAD_FILE_METHOD = "synapse/download-file";
+var EVENT_MAP = {
+  "tool-result": TOOL_RESULT_METHOD,
+  "tool-input": TOOL_INPUT_METHOD,
+  "tool-input-partial": TOOL_INPUT_PARTIAL_METHOD,
+  "tool-cancelled": TOOL_CANCELLED_METHOD,
+  teardown: RESOURCE_TEARDOWN_METHOD
+};
+function resolveEventMethod(name) {
+  return EVENT_MAP[name] ?? name;
+}
+
+// src/keyboard.ts
+var KeyboardForwarder = class {
+  listener;
+  destroyed = false;
+  constructor(transport, customKeys) {
+    const config = customKeys ?? null;
+    this.listener = (event) => {
+      if (this.destroyed) return;
+      if (this.shouldForward(event, config)) {
+        event.preventDefault();
+        transport.send("synapse/keydown", {
+          key: event.key,
+          ctrlKey: event.ctrlKey,
+          metaKey: event.metaKey,
+          shiftKey: event.shiftKey,
+          altKey: event.altKey
+        });
+      }
+    };
+    document.addEventListener("keydown", this.listener);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    document.removeEventListener("keydown", this.listener);
+  }
+  shouldForward(event, config) {
+    if (config && config.length === 0) return false;
+    if (config) {
+      return config.some(
+        (k) => event.key.toLowerCase() === k.key.toLowerCase() && (k.ctrl === void 0 || event.ctrlKey === k.ctrl) && (k.meta === void 0 || event.metaKey === k.meta) && (k.shift === void 0 || event.shiftKey === k.shift) && (k.alt === void 0 || event.altKey === k.alt)
+      );
+    }
+    if (event.key === "Escape") return true;
+    if (event.ctrlKey || event.metaKey) {
+      const key = event.key.toLowerCase();
+      if (key === "c" || key === "v" || key === "x" || key === "a") return false;
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/resize.ts
+function createResizer(send, autoResize) {
+  let destroyed = false;
+  let observer = null;
+  let rafId = null;
+  function measureAndSend() {
+    if (destroyed) return;
+    const width = document.body.scrollWidth;
+    const height = document.body.scrollHeight;
+    send("ui/notifications/size-changed", { width, height });
+  }
+  function resize(width, height) {
+    if (destroyed) return;
+    if (width !== void 0 && height !== void 0) {
+      send("ui/notifications/size-changed", { width, height });
+    } else {
+      measureAndSend();
+    }
+  }
+  if (autoResize && typeof ResizeObserver !== "undefined") {
+    observer = new ResizeObserver(() => {
+      if (destroyed) return;
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        measureAndSend();
+      });
+    });
+    observer.observe(document.body);
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    if (rafId !== null) cancelAnimationFrame(rafId);
+    observer?.disconnect();
+    observer = null;
+  }
+  return { resize, measureAndSend, destroy };
+}
+
+// src/transport.ts
+var SynapseTransport = class {
+  counter = 0;
+  destroyed = false;
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  listener;
+  constructor() {
+    this.listener = (event) => this.handleMessage(event);
+    window.addEventListener("message", this.listener);
+  }
+  send(method, params) {
+    if (this.destroyed) return;
+    const msg = {
+      jsonrpc: "2.0",
+      method,
+      ...params !== void 0 && { params }
+    };
+    window.parent.postMessage(msg, "*");
+  }
+  request(method, params) {
+    if (this.destroyed) {
+      return Promise.reject(new Error("Transport destroyed"));
+    }
+    const id = `syn-${++this.counter}`;
+    const msg = {
+      jsonrpc: "2.0",
+      method,
+      id,
+      ...params !== void 0 && { params }
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      window.parent.postMessage(msg, "*");
+    });
+  }
+  onMessage(method, callback) {
+    if (!this.handlers.has(method)) {
+      this.handlers.set(method, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(method)?.add(callback);
+    return () => {
+      const set = this.handlers.get(method);
+      if (set) {
+        set.delete(callback);
+        if (set.size === 0) {
+          this.handlers.delete(method);
+        }
+      }
+    };
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    window.removeEventListener("message", this.listener);
+    const error = new Error("Transport destroyed");
+    for (const entry of this.pending.values()) {
+      entry.reject(error);
+    }
+    this.pending.clear();
+    this.handlers.clear();
+  }
+  handleMessage(event) {
+    if (this.destroyed) return;
+    const data = event.data;
+    if (!data || data.jsonrpc !== "2.0") return;
+    if ("id" in data && data.id && !("method" in data)) {
+      const response = data;
+      const entry = this.pending.get(response.id);
+      if (!entry) return;
+      this.pending.delete(response.id);
+      if (response.error) {
+        const err = new Error(response.error.message);
+        err.code = response.error.code;
+        err.data = response.error.data;
+        entry.reject(err);
+      } else {
+        entry.resolve(response.result);
+      }
+      return;
+    }
+    if ("method" in data && !("id" in data && data.id)) {
+      const notification = data;
+      const set = this.handlers.get(notification.method);
+      if (set) {
+        for (const handler of set) {
+          handler(notification.params);
+        }
+      }
+    }
+  }
+};
 
-// src/core.ts
-var READ_RESOURCE_METHOD2 = "resources/read";
-function createSynapse(options) {
-  const { name, version, internal = false, forwardKeys } = options;
+// src/connect.ts
+var READ_RESOURCE_METHOD = "resources/read";
+var UPDATE_MODEL_CONTEXT_METHOD = "ui/update-model-context";
+async function connect(options) {
+  const { name, version, autoResize = false, internal = false, forwardKeys } = options;
   const transport = new SynapseTransport();
-  let hostInfo = null;
-  let currentHostContext = {};
-  let currentFontFaces;
-  function syncFontFaces(ctx) {
-    currentFontFaces = foldFontFaces(currentFontFaces, ctx);
-    return currentFontFaces;
-  }
-  function resolveTheme(ctx) {
-    const theme = extractTheme(ctx);
-    return currentFontFaces ? { ...theme, fontFaces: currentFontFaces } : theme;
-  }
-  let hostTasksCapability = null;
   let destroyed = false;
-  const taskStatusRouter = createTaskStatusRouter(transport);
-  let stateTimer = null;
+  let hostContext = {};
+  let hostInfo = { name: "unknown", version: "unknown" };
+  let isNimbleBrainHost = false;
+  let toolInfo = null;
+  let containerDimensions = null;
+  let hostTasksCapability;
   let keyboard = null;
+  let fontFaces;
+  function resolveTheme() {
+    const theme = extractTheme(hostContext);
+    return fontFaces ? { ...theme, fontFaces } : theme;
+  }
+  const handlers = /* @__PURE__ */ new Map();
+  const themeCallbacks = /* @__PURE__ */ new Set();
+  const hostContextCallbacks = /* @__PURE__ */ new Set();
+  const dataCallbacks = /* @__PURE__ */ new Set();
+  const actionCallbacks = /* @__PURE__ */ new Set();
+  const resizer = createResizer((method, params) => transport.send(method, params), autoResize);
+  resizer.measureAndSend();
   const appCapabilities = {
     tasks: {
       cancel: {},
@@ -612,30 +460,58 @@ function createSynapse(options) {
     appInfo: { name, version },
     appCapabilities
   };
-  const ready = transport.request(INITIALIZE_METHOD, initParams).then((result) => {
-    hostInfo = detectHost(result);
-    currentHostContext = result?.hostContext ?? {};
-    const initResult = result;
-    const rawTasks = initResult?.hostCapabilities?.tasks;
+  const result = await transport.request(
+    INITIALIZE_METHOD,
+    initParams
+  );
+  if (result) {
+    const detected = detectHost(result);
+    isNimbleBrainHost = detected.isNimbleBrain;
+    hostInfo = {
+      name: result.hostInfo?.name ?? "unknown",
+      version: result.hostInfo?.version ?? "unknown"
+    };
+    const rawTasks = result.hostCapabilities?.tasks;
     hostTasksCapability = rawTasks && typeof rawTasks === "object" && !Array.isArray(rawTasks) ? rawTasks : void 0;
-    {
-      const theme = extractTheme(currentHostContext);
-      applyTheme(theme.mode, theme.tokens, syncFontFaces(currentHostContext));
+    const ctx = result.hostContext;
+    if (ctx) {
+      hostContext = ctx;
+      fontFaces = foldFontFaces(fontFaces, ctx);
+      if (ctx.toolInfo && typeof ctx.toolInfo === "object") {
+        toolInfo = { tool: ctx.toolInfo.tool ?? {} };
+      }
+      if (ctx.containerDimensions && typeof ctx.containerDimensions === "object") {
+        containerDimensions = ctx.containerDimensions;
+      }
+      const theme = resolveTheme();
+      applyTheme(theme.mode, theme.tokens, theme.fontFaces);
+    }
+  }
+  if (forwardKeys && isNimbleBrainHost) {
+    keyboard = new KeyboardForwarder(transport, forwardKeys === true ? void 0 : forwardKeys);
+  }
+  function fanOutRaw(method, params) {
+    const set = handlers.get(method);
+    if (!set) return;
+    for (const handler of set) handler(params);
+  }
+  transport.onMessage(HOST_CONTEXT_CHANGED_METHOD, (params) => {
+    if (destroyed) return;
+    const ctx = params ?? {};
+    const prevTheme = resolveTheme();
+    hostContext = { ...hostContext, ...ctx };
+    fontFaces = foldFontFaces(fontFaces, ctx);
+    const nextTheme = resolveTheme();
+    applyTheme(nextTheme.mode, nextTheme.tokens, nextTheme.fontFaces);
+    for (const cb of hostContextCallbacks) cb(hostContext);
+    fanOutRaw(HOST_CONTEXT_CHANGED_METHOD, params);
+    if (!themesEqual(prevTheme, nextTheme)) {
+      for (const cb of themeCallbacks) cb(nextTheme);
     }
-    for (const cb of hostContextCallbacks) cb(currentHostContext);
-    transport.send(INITIALIZED_METHOD, {});
-    keyboard = new KeyboardForwarder(transport, forwardKeys);
-  });
-  const unsubHostContext = transport.onMessage(HOST_CONTEXT_CHANGED_METHOD, (params) => {
-    currentHostContext = params ?? {};
-    const theme = extractTheme(currentHostContext);
-    applyTheme(theme.mode, theme.tokens, syncFontFaces(currentHostContext));
-    for (const cb of hostContextCallbacks) cb(currentHostContext);
   });
-  const hostContextCallbacks = /* @__PURE__ */ new Set();
-  const dataCallbacks = /* @__PURE__ */ new Set();
-  const actionCallbacks = /* @__PURE__ */ new Set();
-  const unsubData = transport.onMessage("synapse/data-changed", (params) => {
+  transport.onMessage(DATA_CHANGED_METHOD, (params) => {
+    if (destroyed) return;
+    fanOutRaw(DATA_CHANGED_METHOD, params);
     if (!params) return;
     const event = {
       source: "agent",
@@ -644,119 +520,157 @@ function createSynapse(options) {
     };
     for (const cb of dataCallbacks) cb(event);
   });
-  const unsubAction = transport.onMessage("synapse/action", (params) => {
+  transport.onMessage(ACTION_METHOD, (params) => {
+    if (destroyed) return;
+    fanOutRaw(ACTION_METHOD, params);
     if (!params || typeof params.type !== "string") return;
-    const action = {
+    const action2 = {
       type: params.type,
       payload: params.payload ?? {},
       requiresConfirmation: params.requiresConfirmation === true,
       label: typeof params.label === "string" ? params.label : void 0
     };
-    for (const cb of actionCallbacks) cb(action);
+    for (const cb of actionCallbacks) cb(action2);
   });
-  const isNB = () => hostInfo?.isNimbleBrain === true;
-  const synapse = {
-    get ready() {
-      return ready;
+  const subscribedMethods = /* @__PURE__ */ new Set([
+    HOST_CONTEXT_CHANGED_METHOD,
+    DATA_CHANGED_METHOD,
+    ACTION_METHOD
+  ]);
+  function ensureTransportSub(method) {
+    if (subscribedMethods.has(method)) return;
+    subscribedMethods.add(method);
+    const isToolResult = method === TOOL_RESULT_METHOD;
+    transport.onMessage(method, (params) => {
+      if (destroyed) return;
+      const set = handlers.get(method);
+      if (!set) return;
+      for (const handler of set) {
+        if (isToolResult) {
+          handler(parseToolResultParams(params));
+        } else {
+          handler(params);
+        }
+      }
+    });
+  }
+  function subscribe(event, handler) {
+    switch (event) {
+      case "theme-changed":
+        themeCallbacks.add(handler);
+        return () => {
+          themeCallbacks.delete(handler);
+        };
+      case "host-context-changed":
+        hostContextCallbacks.add(handler);
+        return () => {
+          hostContextCallbacks.delete(handler);
+        };
+      case "data-changed":
+        dataCallbacks.add(handler);
+        return () => {
+          dataCallbacks.delete(handler);
+        };
+      case "action":
+        actionCallbacks.add(handler);
+        return () => {
+          actionCallbacks.delete(handler);
+        };
+      default: {
+        const method = resolveEventMethod(event);
+        if (!handlers.has(method)) handlers.set(method, /* @__PURE__ */ new Set());
+        handlers.get(method)?.add(handler);
+        ensureTransportSub(method);
+        return () => {
+          const set = handlers.get(method);
+          if (set) {
+            set.delete(handler);
+            if (set.size === 0) handlers.delete(method);
+          }
+        };
+      }
+    }
+  }
+  if (options.on) {
+    for (const [event, handler] of Object.entries(options.on)) {
+      if (typeof handler === "function") subscribe(event, handler);
+    }
+  }
+  transport.send(INITIALIZED_METHOD, {});
+  const taskRouter = createTaskStatusRouter(transport);
+  const app = {
+    get theme() {
+      return resolveTheme();
+    },
+    get hostInfo() {
+      return { ...hostInfo };
+    },
+    get hostContext() {
+      return hostContext;
     },
     get isNimbleBrainHost() {
-      return isNB();
+      return isNimbleBrainHost;
+    },
+    get toolInfo() {
+      return toolInfo;
+    },
+    get containerDimensions() {
+      return containerDimensions;
     },
     get destroyed() {
       return destroyed;
     },
-    async callTool(toolName, args) {
+    get supportsTasks() {
+      return hostTasksCapability?.requests?.tools?.call !== void 0;
+    },
+    on(event, handler) {
+      return subscribe(event, handler);
+    },
+    resize(width, height) {
+      resizer.resize(width, height);
+    },
+    openLink(url) {
+      if (destroyed) return;
+      const params = { url };
+      transport.request(OPEN_LINK_METHOD, params).catch(() => {
+        window.open(url, "_blank", "noopener");
+      });
+    },
+    updateModelContext(state, summary) {
+      if (destroyed) return;
+      const params = {
+        structuredContent: state,
+        ...summary !== void 0 && {
+          content: [{ type: "text", text: summary }]
+        }
+      };
+      transport.send(UPDATE_MODEL_CONTEXT_METHOD, params);
+    },
+    async callTool(toolName, args, callOptions) {
+      const server = callOptions?.server ?? (internal ? name : void 0);
       const params = {
         name: toolName,
-        arguments: args ?? {}
+        arguments: args ?? {},
+        ...server !== void 0 && { server }
       };
-      if (internal) {
-        params.server = name;
-      }
-      const raw = await transport.request("tools/call", params);
+      const raw = await transport.request(TOOLS_CALL_METHOD, params);
       return parseToolResult(raw);
     },
-    async callToolAsTask(toolName, args, options2) {
-      return callToolAsTask(
-        {
-          transport,
-          router: taskStatusRouter,
-          getHostTasksCapability: () => hostTasksCapability,
-          appName: name,
-          internalApp: internal
-        },
-        toolName,
-        args,
-        options2
-      );
-    },
-    async readResource(uri) {
-      const params = { uri };
+    async readServerResource(params) {
       const raw = await transport.request(
-        READ_RESOURCE_METHOD2,
+        READ_RESOURCE_METHOD,
         params
       );
       return raw;
     },
-    onDataChanged(callback) {
-      dataCallbacks.add(callback);
-      return () => {
-        dataCallbacks.delete(callback);
-      };
-    },
-    onAction(callback) {
-      actionCallbacks.add(callback);
-      return () => {
-        actionCallbacks.delete(callback);
-      };
-    },
-    getHostContext() {
-      return currentHostContext;
-    },
-    onHostContextChanged(callback) {
-      hostContextCallbacks.add(callback);
-      return () => {
-        hostContextCallbacks.delete(callback);
-      };
-    },
-    getTheme() {
-      return resolveTheme(currentHostContext);
-    },
-    // Selector over `onHostContextChanged`: only fires when the *derived*
-    // theme actually changes, so theme subscribers don't see spurious
-    // updates when other host-context fields (e.g. workspace) change.
-    //
-    // Subscriber timing matters:
-    //  - Subscribed BEFORE handshake: `prev = null` sentinel. The first
-    //    fire (the handshake dispatch) always invokes the callback,
-    //    even if the host's theme happens to derive to the default.
-    //    Otherwise consumers using `onThemeChanged` as their init
-    //    signal would silently miss it.
-    //  - Subscribed AFTER handshake: `prev` is pre-seeded with the
-    //    current derived theme, so a workspace-only `host-context-changed`
-    //    notification correctly filters as a no-op.
-    onThemeChanged(callback) {
-      let prev = hostInfo !== null ? resolveTheme(currentHostContext) : null;
-      const wrapped = (ctx) => {
-        const next = resolveTheme(ctx);
-        if (prev !== null && themesEqual(prev, next)) return;
-        prev = next;
-        callback(next);
-      };
-      hostContextCallbacks.add(wrapped);
-      return () => {
-        hostContextCallbacks.delete(wrapped);
-      };
-    },
-    action(action, params) {
-      if (!isNB()) return;
-      transport.send("synapse/action", { action, ...params });
-    },
-    chat(message, context) {
+    sendMessage(text, context) {
+      if (destroyed) return;
       const textBlock = {
         type: "text",
-        text: message,
-        ...isNB() && context && { _meta: { context } }
+        text,
+        // `_meta.context` is a NimbleBrain convention; other hosts ignore it,
+        // but there is no reason to spend the bytes off one.
+        ...isNimbleBrainHost && context && { _meta: { context } }
       };
       const params = {
         role: "user",
@@ -764,80 +678,87 @@ function createSynapse(options) {
       };
       transport.send(MESSAGE_METHOD, params);
     },
-    setVisibleState(state, summary) {
-      if (stateTimer) clearTimeout(stateTimer);
-      stateTimer = setTimeout(() => {
-        const params = {
-          structuredContent: state,
-          ...summary !== void 0 && {
-            content: [{ type: "text", text: summary }]
-          }
-        };
-        transport.send("ui/update-model-context", params);
-        stateTimer = null;
-      }, 250);
-    },
-    downloadFile(filename, content, mimeType) {
-      const resolvedMime = mimeType || (content instanceof Blob ? content.type : "") || "application/octet-stream";
-      const blob = content instanceof Blob ? content : new Blob([content], { type: resolvedMime });
-      transport.send("synapse/download-file", {
-        data: blob,
-        filename,
-        mimeType: resolvedMime
-      });
-    },
-    openLink(url) {
-      const params = { url };
-      transport.request(OPEN_LINK_METHOD, params).catch(() => {
-        window.open(url, "_blank", "noopener");
-      });
-    },
-    async pickFile(options2) {
-      if (!isNB()) {
-        throw new Error("pickFile is not supported in this host");
-      }
-      const result = await requestFile(transport, options2, false);
-      if (result === null) return null;
-      return Array.isArray(result) ? result[0] ?? null : result;
-    },
-    async pickFiles(options2) {
-      if (!isNB()) {
-        throw new Error("pickFiles is not supported in this host");
-      }
-      const result = await requestFile(transport, options2, true);
-      if (result === null) return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    _onMessage(method, callback) {
-      return transport.onMessage(method, callback);
-    },
-    _request(method, params) {
-      return transport.request(method, params);
-    },
-    get _hostTasksCapability() {
-      return hostTasksCapability;
-    },
     destroy() {
       if (destroyed) return;
       destroyed = true;
-      if (stateTimer) clearTimeout(stateTimer);
       keyboard?.destroy();
-      unsubHostContext();
-      unsubData();
-      unsubAction();
-      taskStatusRouter.dispose();
+      resizer.destroy();
+      taskRouter.dispose();
+      handlers.clear();
+      themeCallbacks.clear();
       hostContextCallbacks.clear();
       dataCallbacks.clear();
       actionCallbacks.clear();
       transport.destroy();
     }
   };
-  return synapse;
+  registerInternals(app, {
+    send(method, params) {
+      if (destroyed) return;
+      transport.send(method, params);
+    },
+    request(method, params) {
+      return transport.request(method, params);
+    },
+    onMessage(method, handler) {
+      return transport.onMessage(method, handler);
+    },
+    taskRouter,
+    get hostTasksCapability() {
+      return hostTasksCapability;
+    },
+    appName: name,
+    internalApp: internal
+  });
+  return app;
+}
+function themesEqual(a, b) {
+  if (a.mode !== b.mode) return false;
+  if (fontFacesKey(a.fontFaces) !== fontFacesKey(b.fontFaces)) return false;
+  const aKeys = Object.keys(a.tokens);
+  const bKeys = Object.keys(b.tokens);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const k of aKeys) {
+    if (a.tokens[k] !== b.tokens[k]) return false;
+  }
+  return true;
+}
+
+// src/extensions.ts
+var DEFAULT_MAX_FILE_SIZE = 26214400;
+function action(app, name, params) {
+  if (!app.isNimbleBrainHost) return;
+  internalsFor(app).send(ACTION_METHOD, { action: name, ...params });
 }
-async function requestFile(transport, options, multiple) {
-  const result = await transport.request("synapse/request-file", {
+function downloadFile(app, filename, content, mimeType) {
+  const resolvedMime = mimeType || (content instanceof Blob ? content.type : "") || "application/octet-stream";
+  const blob = content instanceof Blob ? content : new Blob([content], { type: resolvedMime });
+  internalsFor(app).send(DOWNLOAD_FILE_METHOD, {
+    data: blob,
+    filename,
+    mimeType: resolvedMime
+  });
+}
+async function pickFile(app, options) {
+  if (!app.isNimbleBrainHost) {
+    throw new Error("pickFile is not supported in this host");
+  }
+  const result = await requestFile(app, options, false);
+  if (result === null) return null;
+  return Array.isArray(result) ? result[0] ?? null : result;
+}
+async function pickFiles(app, options) {
+  if (!app.isNimbleBrainHost) {
+    throw new Error("pickFiles is not supported in this host");
+  }
+  const result = await requestFile(app, options, true);
+  if (result === null) return [];
+  return Array.isArray(result) ? result : [result];
+}
+async function requestFile(app, options, multiple) {
+  const result = await internalsFor(app).request(REQUEST_FILE_METHOD, {
     accept: options?.accept,
-    maxSize: options?.maxSize ?? 26214400,
+    maxSize: options?.maxSize ?? DEFAULT_MAX_FILE_SIZE,
     multiple
   });
   if (result == null) return null;
@@ -854,18 +775,7 @@ function validateFileResult(value) {
   }
   return value;
 }
-function themesEqual(a, b) {
-  if (a.mode !== b.mode || a.primaryColor !== b.primaryColor) return false;
-  if (fontFacesKey(a.fontFaces) !== fontFacesKey(b.fontFaces)) return false;
-  const aKeys = Object.keys(a.tokens);
-  const bKeys = Object.keys(b.tokens);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const k of aKeys) {
-    if (a.tokens[k] !== b.tokens[k]) return false;
-  }
-  return true;
-}
 
-export { connect, createSynapse };
-//# sourceMappingURL=chunk-GNTQJSQX.js.map
-//# sourceMappingURL=chunk-GNTQJSQX.js.map
+export { action, callToolAsTask, connect, downloadFile, pickFile, pickFiles };
+//# sourceMappingURL=chunk-VYR6V47N.js.map
+//# sourceMappingURL=chunk-VYR6V47N.js.map