@nimblebrain/synapse 0.19.0 → 0.21.0

package/dist/chunk-HQLSVUOR.cjs

@@ -0,0 +1,667 @@
+'use strict';
+
+var chunkYSL7KJNU_cjs = require('./chunk-YSL7KJNU.cjs');
+var chunkISV6HFQE_cjs = require('./chunk-ISV6HFQE.cjs');
+var extApps = require('@modelcontextprotocol/ext-apps');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+
+// src/errors.ts
+var HostCapabilityError = class extends Error {
+  capability;
+  constructor(feature, capability) {
+    super(`${feature} is not supported in this host: it did not declare ${capability}`);
+    this.name = "HostCapabilityError";
+    this.capability = capability;
+  }
+};
+
+// 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)."
+    );
+  }
+  return internals;
+}
+
+// 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/task-handle.ts
+var TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
+function readHostTasksCapability(capabilities) {
+  const entry = capabilities?.experimental?.[TASKS_EXTENSION_ID];
+  return entry && typeof entry === "object" && !Array.isArray(entry) ? entry : void 0;
+}
+var TASKS_GET_METHOD = "tasks/get";
+var TASKS_RESULT_METHOD = "tasks/result";
+var TASKS_CANCEL_METHOD = "tasks/cancel";
+var TASKS_STATUS_NOTIFICATION_METHOD = "notifications/tasks/status";
+function createTaskStatusRouter(subscribe) {
+  const listeners = /* @__PURE__ */ new Map();
+  const unsub = subscribe(TASKS_STATUS_NOTIFICATION_METHOD, (rawParams) => {
+    if (!rawParams) return;
+    const params = rawParams;
+    const taskId = params.taskId;
+    if (typeof taskId !== "string") return;
+    const set = listeners.get(taskId);
+    if (!set || set.size === 0) return;
+    const update = {
+      taskId: params.taskId,
+      status: params.status,
+      ...params.statusMessage !== void 0 && { statusMessage: params.statusMessage }
+    };
+    for (const cb of set) cb(update);
+  });
+  return {
+    subscribe(taskId, cb) {
+      let set = listeners.get(taskId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(taskId, set);
+      }
+      set.add(cb);
+      return () => {
+        const s = listeners.get(taskId);
+        if (!s) return;
+        s.delete(cb);
+        if (s.size === 0) listeners.delete(taskId);
+      };
+    },
+    dispose() {
+      listeners.clear();
+      unsub();
+    }
+  };
+}
+async function callToolAsTask(app, toolName, args, options) {
+  const deps = internalsFor(app);
+  const hostTasks = deps.hostTasksCapability;
+  if (!hostTasks?.requests?.tools?.call) {
+    throw new HostCapabilityError(
+      "callToolAsTask",
+      `${TASKS_EXTENSION_ID} with requests.tools.call`
+    );
+  }
+  const taskParam = {};
+  if (options?.ttl !== void 0) taskParam.ttl = options.ttl;
+  const callParams = {
+    name: toolName,
+    arguments: args ?? {},
+    task: taskParam
+  };
+  const raw = await deps.request(
+    chunkISV6HFQE_cjs.TOOLS_CALL_METHOD,
+    callParams
+  );
+  const createResult = raw;
+  const initialTask = createResult?.task;
+  if (!initialTask || typeof initialTask !== "object" || typeof initialTask.taskId !== "string") {
+    throw new Error(
+      "callToolAsTask: receiver returned a response without `task` per CreateTaskResult (expected shape: `{ task: { taskId, status, ... } }`). Receiver may not honor the advertised tasks capability."
+    );
+  }
+  const taskId = initialTask.taskId;
+  const localCallbacks = /* @__PURE__ */ new Map();
+  const handle = {
+    task: initialTask,
+    async result() {
+      const params = { taskId };
+      const rawResult = await deps.request(
+        TASKS_RESULT_METHOD,
+        params
+      );
+      const typed = rawResult;
+      return parseToolResult(typed);
+    },
+    async refresh() {
+      const params = { taskId };
+      const raw2 = await deps.request(
+        TASKS_GET_METHOD,
+        params
+      );
+      return projectTask(raw2);
+    },
+    async cancel() {
+      const params = { taskId };
+      const raw2 = await deps.request(
+        TASKS_CANCEL_METHOD,
+        params
+      );
+      return projectTask(raw2);
+    },
+    onStatus(cb) {
+      const existing = localCallbacks.get(cb);
+      if (existing) return existing;
+      const wireUnsub = deps.taskRouter.subscribe(taskId, (update) => {
+        const merged = {
+          taskId: update.taskId,
+          status: update.status,
+          ttl: initialTask.ttl,
+          createdAt: initialTask.createdAt,
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...initialTask.pollInterval !== void 0 && {
+            pollInterval: initialTask.pollInterval
+          },
+          ...update.statusMessage !== void 0 && { statusMessage: update.statusMessage }
+        };
+        cb(merged);
+      });
+      const unsub = () => {
+        localCallbacks.delete(cb);
+        wireUnsub();
+      };
+      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 }
+  };
+}
+
+// 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 };
+}
+
+// src/keyboard.ts
+var KeyboardForwarder = class {
+  listener;
+  destroyed = false;
+  constructor(send, customKeys) {
+    const config = customKeys ?? null;
+    this.listener = (event) => {
+      if (this.destroyed) return;
+      if (this.shouldForward(event, config)) {
+        event.preventDefault();
+        send(chunkISV6HFQE_cjs.KEYDOWN_METHOD, {
+          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;
+  }
+};
+function createResizer(send, autoResize) {
+  let destroyed = false;
+  let observer = null;
+  function measureAndSend() {
+    if (destroyed) return;
+    const width = document.body.scrollWidth;
+    const height = document.body.scrollHeight;
+    send(extApps.SIZE_CHANGED_METHOD, { width, height });
+  }
+  function resize(width, height) {
+    if (destroyed) return;
+    if (width !== void 0 && height !== void 0) {
+      send(extApps.SIZE_CHANGED_METHOD, { width, height });
+    } else {
+      measureAndSend();
+    }
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    observer?.disconnect();
+    observer = null;
+  }
+  return { resize, measureAndSend, destroy };
+}
+
+// src/connect.ts
+var NIMBLEBRAIN_HOST = "nimblebrain";
+var CHAT_CONTEXT_META_KEY = "ai.nimblebrain/context";
+var NO_DEADLINE = { timeout: 2147483647 };
+var MAPPED_EVENTS = [
+  ["toolinput", extApps.TOOL_INPUT_METHOD],
+  ["toolinputpartial", extApps.TOOL_INPUT_PARTIAL_METHOD],
+  ["toolresult", extApps.TOOL_RESULT_METHOD],
+  ["toolcancelled", extApps.TOOL_CANCELLED_METHOD]
+];
+async function connect(options) {
+  const { name, version, autoResize = false, forwardKeys } = options;
+  let destroyed = false;
+  let hostInfo = { name: "unknown", version: "unknown" };
+  let isNimbleBrainHost = false;
+  let toolInfo = null;
+  let containerDimensions = null;
+  let hostCapabilities = {};
+  let hostTasksCapability;
+  let keyboard = null;
+  let appliedTheme = { mode: "light", tokens: {} };
+  const appCapabilities = {
+    tasks: {
+      cancel: {},
+      requests: { tools: { call: {} } }
+    }
+  };
+  const client = new extApps.App(
+    { name, version },
+    appCapabilities,
+    { autoResize }
+  );
+  function currentContext() {
+    return client.getHostContext() ?? {};
+  }
+  function resolveTheme() {
+    return chunkYSL7KJNU_cjs.extractTheme(currentContext());
+  }
+  function applyFontsFrom(ctx) {
+    const css = chunkYSL7KJNU_cjs.extractHostFontCss(ctx);
+    if (css !== void 0 && typeof document !== "undefined") extApps.applyHostFonts(css);
+  }
+  function applyResolvedTheme() {
+    const theme = resolveTheme();
+    chunkYSL7KJNU_cjs.applyTheme(theme.mode, theme.tokens);
+    appliedTheme = theme;
+    return theme;
+  }
+  const handlers = /* @__PURE__ */ new Map();
+  const themeCallbacks = /* @__PURE__ */ new Set();
+  const hostContextCallbacks = /* @__PURE__ */ new Set();
+  function fanOut(method, payload) {
+    const set = handlers.get(method);
+    if (!set) return;
+    for (const handler of set) handler(payload);
+  }
+  function sendRaw(method, params) {
+    if (destroyed) return;
+    void client.notification({ method, params }).catch(() => {
+    });
+  }
+  function requestRaw(method, params) {
+    return client.request({ method, params }, types_js.ResultSchema, NO_DEADLINE);
+  }
+  for (const [event, method] of MAPPED_EVENTS) {
+    client.addEventListener(event, (params) => {
+      if (destroyed) return;
+      fanOut(
+        method,
+        method === extApps.TOOL_RESULT_METHOD ? parseToolResultParams(params) : params
+      );
+    });
+  }
+  client.addEventListener("hostcontextchanged", (params) => {
+    if (destroyed) return;
+    const prevTheme = appliedTheme;
+    applyFontsFrom(params);
+    const nextTheme = applyResolvedTheme();
+    const merged = currentContext();
+    for (const cb of hostContextCallbacks) cb(merged);
+    fanOut(extApps.HOST_CONTEXT_CHANGED_METHOD, params);
+    if (!themesEqual(prevTheme, nextTheme)) {
+      for (const cb of themeCallbacks) cb(nextTheme);
+    }
+  });
+  client.onteardown = (params) => {
+    if (!destroyed) fanOut(extApps.RESOURCE_TEARDOWN_METHOD, params);
+    return {};
+  };
+  client.fallbackNotificationHandler = async (notification) => {
+    if (destroyed) return;
+    fanOut(notification.method, notification.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);
+        };
+      default: {
+        const method = chunkISV6HFQE_cjs.resolveEventMethod(event);
+        if (!handlers.has(method)) handlers.set(method, /* @__PURE__ */ new Set());
+        handlers.get(method)?.add(handler);
+        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);
+    }
+  }
+  await client.connect();
+  const hostVersion = client.getHostVersion();
+  hostInfo = {
+    name: hostVersion?.name ?? "unknown",
+    version: hostVersion?.version ?? "unknown"
+  };
+  isNimbleBrainHost = hostInfo.name === NIMBLEBRAIN_HOST;
+  hostCapabilities = client.getHostCapabilities() ?? {};
+  hostTasksCapability = readHostTasksCapability(hostCapabilities);
+  const initialContext = client.getHostContext();
+  if (initialContext) {
+    if (initialContext.toolInfo && typeof initialContext.toolInfo === "object") {
+      toolInfo = {
+        tool: initialContext.toolInfo.tool ?? {}
+      };
+    }
+    if (initialContext.containerDimensions && typeof initialContext.containerDimensions === "object") {
+      containerDimensions = initialContext.containerDimensions;
+    }
+    applyFontsFrom(initialContext);
+    applyResolvedTheme();
+  }
+  if (forwardKeys && hostCapabilities.experimental?.[chunkISV6HFQE_cjs.NIMBLEBRAIN_EXTENSIONS.keydown.capability] !== void 0) {
+    keyboard = new KeyboardForwarder(sendRaw, forwardKeys === true ? void 0 : forwardKeys);
+  }
+  const resizer = createResizer(sendRaw);
+  if (!autoResize) resizer.measureAndSend();
+  const taskRouter = createTaskStatusRouter(
+    (method, handler) => subscribe(method, handler)
+  );
+  const app = {
+    get theme() {
+      return resolveTheme();
+    },
+    get hostInfo() {
+      return { ...hostInfo };
+    },
+    get hostContext() {
+      return currentContext();
+    },
+    get hostCapabilities() {
+      return hostCapabilities;
+    },
+    get isNimbleBrainHost() {
+      return isNimbleBrainHost;
+    },
+    get toolInfo() {
+      return toolInfo;
+    },
+    get containerDimensions() {
+      return containerDimensions;
+    },
+    get destroyed() {
+      return destroyed;
+    },
+    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;
+      if (!hostCapabilities.openLinks) {
+        window.open(url, "_blank", "noopener");
+        return;
+      }
+      const params = { url };
+      client.openLink(params, NO_DEADLINE).catch(() => {
+        window.open(url, "_blank", "noopener");
+      });
+    },
+    updateModelContext(state, summary) {
+      if (destroyed || !hostCapabilities.updateModelContext) return;
+      const params = {
+        structuredContent: state,
+        ...summary !== void 0 && {
+          content: [{ type: "text", text: summary }]
+        }
+      };
+      client.updateModelContext(params, NO_DEADLINE).catch(() => {
+      });
+    },
+    async callTool(toolName, args) {
+      if (!hostCapabilities.serverTools) {
+        throw new HostCapabilityError("callTool", "serverTools");
+      }
+      const params = {
+        name: toolName,
+        arguments: args ?? {}
+      };
+      const raw = await client.request(
+        { method: chunkISV6HFQE_cjs.TOOLS_CALL_METHOD, params },
+        types_js.CallToolResultSchema,
+        NO_DEADLINE
+      );
+      return parseToolResult(raw);
+    },
+    async readServerResource(params) {
+      if (!hostCapabilities.serverResources) {
+        throw new HostCapabilityError("readServerResource", "serverResources");
+      }
+      return await client.readServerResource(params, NO_DEADLINE);
+    },
+    sendMessage(text, context) {
+      if (destroyed || !hostCapabilities.message) return;
+      const textBlock = {
+        type: "text",
+        text,
+        // The chat context is a NimbleBrain host field; other hosts ignore it,
+        // but there is no reason to spend the bytes off one.
+        ...isNimbleBrainHost && context && { _meta: { [CHAT_CONTEXT_META_KEY]: context } }
+      };
+      const params = {
+        role: "user",
+        content: [textBlock]
+      };
+      client.sendMessage(params, NO_DEADLINE).catch(() => {
+      });
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      keyboard?.destroy();
+      resizer.destroy();
+      taskRouter.dispose();
+      handlers.clear();
+      themeCallbacks.clear();
+      hostContextCallbacks.clear();
+      void client.close();
+    }
+  };
+  registerInternals(app, {
+    send(method, params) {
+      sendRaw(method, params);
+    },
+    request(method, params) {
+      return requestRaw(method, params);
+    },
+    onMessage(method, handler) {
+      return subscribe(method, handler);
+    },
+    taskRouter,
+    get hostTasksCapability() {
+      return hostTasksCapability;
+    }
+  });
+  return app;
+}
+function themesEqual(a, b) {
+  if (a.mode !== b.mode) 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
+function hostSupports(app, extension) {
+  const { capability } = chunkISV6HFQE_cjs.NIMBLEBRAIN_EXTENSIONS[extension];
+  return app.hostCapabilities.experimental?.[capability] !== void 0;
+}
+var DEFAULT_MAX_FILE_SIZE = 26214400;
+function action(app, name, params) {
+  if (!hostSupports(app, "action")) return;
+  internalsFor(app).send(chunkISV6HFQE_cjs.NIMBLEBRAIN_EXTENSIONS.action.method, { action: name, ...params });
+}
+async function pickFile(app, options) {
+  requireRequestFile("pickFile", app);
+  const files = await requestFile(app, options, false);
+  return files[0] ?? null;
+}
+async function pickFiles(app, options) {
+  requireRequestFile("pickFiles", app);
+  return await requestFile(app, options, true);
+}
+function requireRequestFile(feature, app) {
+  if (!hostSupports(app, "requestFile")) {
+    throw new HostCapabilityError(feature, chunkISV6HFQE_cjs.NIMBLEBRAIN_EXTENSIONS.requestFile.capability);
+  }
+}
+async function requestFile(app, options, multiple) {
+  const result = await internalsFor(app).request(chunkISV6HFQE_cjs.NIMBLEBRAIN_EXTENSIONS.requestFile.method, {
+    accept: options?.accept,
+    maxSize: options?.maxSize ?? DEFAULT_MAX_FILE_SIZE,
+    multiple
+  });
+  const files = result?.files;
+  if (files === void 0) {
+    throw new Error(
+      "ai.nimblebrain/request-file returned no `files`. The host is older than this SDK targets: it answers the picker with a bare array or `null`, which a spec-compliant client cannot parse."
+    );
+  }
+  if (!Array.isArray(files)) {
+    throw new Error("ai.nimblebrain/request-file returned a `files` field that is not an array.");
+  }
+  return files.map(validateFileResult);
+}
+function validateFileResult(value) {
+  if (typeof value !== "object" || value === null || typeof value.id !== "string") {
+    throw new Error(
+      "ai.nimblebrain/request-file returned a result without a string `id`. The host appears to be on a version older than this SDK targets \u2014 @nimblebrain/synapse 0.8.0+ requires a host with POST /v1/resources (NimbleBrain \u2265 the version that ships PR #93)."
+    );
+  }
+  return value;
+}
+
+exports.HostCapabilityError = HostCapabilityError;
+exports.action = action;
+exports.callToolAsTask = callToolAsTask;
+exports.connect = connect;
+exports.hostSupports = hostSupports;
+exports.internalsFor = internalsFor;
+exports.pickFile = pickFile;
+exports.pickFiles = pickFiles;
+//# sourceMappingURL=chunk-HQLSVUOR.cjs.map
+//# sourceMappingURL=chunk-HQLSVUOR.cjs.map