@nimblebrain/synapse 0.17.1 → 0.19.0

package/dist/chunk-VYR6V47N.js

@@ -1,781 +0,0 @@
-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/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 TOOLS_CALL_METHOD = "tools/call";
-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(transport) {
-  const listeners = /* @__PURE__ */ new Map();
-  const unsub = transport.onMessage(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 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 `app.callTool`."
-    );
-  }
-  const taskParam = {};
-  if (options?.ttl !== void 0) taskParam.ttl = options.ttl;
-  const crossServer = options?.internal ?? deps.internalApp;
-  const callParams = {
-    name: toolName,
-    arguments: args ?? {},
-    task: taskParam,
-    ...crossServer ? { server: deps.appName } : {}
-  };
-  const raw = await deps.request(
-    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 };
-}
-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/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 destroyed = false;
-  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: {},
-      requests: { tools: { call: {} } }
-    }
-  };
-  const initParams = {
-    protocolVersion: LATEST_PROTOCOL_VERSION,
-    appInfo: { name, version },
-    appCapabilities
-  };
-  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 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);
-    }
-  });
-  transport.onMessage(DATA_CHANGED_METHOD, (params) => {
-    if (destroyed) return;
-    fanOutRaw(DATA_CHANGED_METHOD, params);
-    if (!params) return;
-    const event = {
-      source: "agent",
-      server: params.server ?? "",
-      tool: params.tool ?? ""
-    };
-    for (const cb of dataCallbacks) cb(event);
-  });
-  transport.onMessage(ACTION_METHOD, (params) => {
-    if (destroyed) return;
-    fanOutRaw(ACTION_METHOD, params);
-    if (!params || typeof params.type !== "string") return;
-    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(action2);
-  });
-  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 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;
-      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 ?? {},
-        ...server !== void 0 && { server }
-      };
-      const raw = await transport.request(TOOLS_CALL_METHOD, 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,
-        // `_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",
-        content: [textBlock]
-      };
-      transport.send(MESSAGE_METHOD, params);
-    },
-    destroy() {
-      if (destroyed) return;
-      destroyed = true;
-      keyboard?.destroy();
-      resizer.destroy();
-      taskRouter.dispose();
-      handlers.clear();
-      themeCallbacks.clear();
-      hostContextCallbacks.clear();
-      dataCallbacks.clear();
-      actionCallbacks.clear();
-      transport.destroy();
-    }
-  };
-  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 });
-}
-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 ?? DEFAULT_MAX_FILE_SIZE,
-    multiple
-  });
-  if (result == null) return null;
-  if (Array.isArray(result)) {
-    return result.map(validateFileResult);
-  }
-  return validateFileResult(result);
-}
-function validateFileResult(value) {
-  if (typeof value !== "object" || value === null || typeof value.id !== "string") {
-    throw new Error(
-      "synapse/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;
-}
-
-export { action, callToolAsTask, connect, downloadFile, pickFile, pickFiles };
-//# sourceMappingURL=chunk-VYR6V47N.js.map
-//# sourceMappingURL=chunk-VYR6V47N.js.map