@pixerate/editor 0.139.1 → 0.140.0

package/dist/chunk-ZAOOIJ6I.cjs

@@ -0,0 +1,1156 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+var _chunkWOFXZ3XUcjs = require('./chunk-WOFXZ3XU.cjs');
+
+// src/tools/skills.ts
+function parseSkillFrontmatter(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(markdown);
+  if (!match) return { body: markdown };
+  const fields = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z_-]+):\s*(.*)$/.exec(line);
+    if (kv) fields[kv[1]] = kv[2].trim().replace(/^(['"])([\s\S]*)\1$/, "$2");
+  }
+  return { name: fields.name, description: fields.description, body: markdown.slice(match[0].length) };
+}
+var normalize = (path) => path.replace(/\\/g, "/").replace(/^\.?\//, "");
+function listSkills(files) {
+  const skills = /* @__PURE__ */ new Map();
+  const paths = Object.keys(files).map(normalize);
+  for (const path of paths) {
+    const [dir, ...rest] = path.split("/");
+    if (rest.join("/") !== "SKILL.md") continue;
+    const { description } = parseSkillFrontmatter(_nullishCoalesce(_nullishCoalesce(files[path], () => ( files[`./${path}`])), () => ( "")));
+    skills.set(dir, { name: dir, description: _nullishCoalesce(description, () => ( "")), references: [] });
+  }
+  for (const path of paths) {
+    const [dir, ...rest] = path.split("/");
+    const file = rest.join("/");
+    if (file && file !== "SKILL.md" && skills.has(dir)) skills.get(dir).references.push(file);
+  }
+  for (const skill of skills.values()) skill.references.sort();
+  return Array.from(skills.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function readSkillFile(files, skill, file = "SKILL.md") {
+  const path = `${skill}/${normalize(file)}`;
+  return _nullishCoalesce(files[path], () => ( files[`./${path}`]));
+}
+
+// src/tools/view.ts
+var TOOL_DISCOVERY_TOOLS = ["list_toolsets", "search_tools", "enable_tools", "disable_tools", "get_skill"];
+var READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var LISTING = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var SELECTION_SCHEMA = {
+  type: "object",
+  properties: {
+    tools: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true,
+      description: 'Exposed tool names, as `search_tools` returns them (e.g. "chart__add_chart_trendline"). Default: none.'
+    },
+    toolsets: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true,
+      description: 'Toolset names from `list_toolsets` (e.g. "chart"); covers every tool in each. Default: none.'
+    }
+  },
+  additionalProperties: false
+};
+var ToolRegistryView = (_class = class {
+  constructor(source, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+    this.source = source;
+    this.allow = options.toolsets;
+    this.readOnly = _nullishCoalesce(options.readOnly, () => ( false));
+    this.discovery = options.discovery ? options.discovery === true ? {} : options.discovery : null;
+    for (const name of _nullishCoalesce(_optionalChain([this, 'access', _ => _.discovery, 'optionalAccess', _2 => _2.enabled]), () => ( []))) this.enabledSets.add(name);
+    this.meta = this.discovery ? this.createDiscoveryTools() : [];
+  }
+  
+  __init() {this.capabilities = { tools: { listChanged: true } }}
+  
+  
+  
+  __init2() {this.enabledSets = /* @__PURE__ */ new Set()}
+  __init3() {this.enabledTools = /* @__PURE__ */ new Set()}
+  __init4() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  __init5() {this.unsubscribe = null}
+  __init6() {this.lastSignature = ""}
+  /** Changes which toolsets the agent may use (`undefined`: all). Fires `listChanged` if the listing changes. */
+  setToolsets(toolsets) {
+    this.allow = toolsets;
+    this.changed();
+  }
+  /**
+   * Lists more tools in a discovery view, as the `enable_tools` tool does.
+   * Throws for names the view does not allow. Returns the tool names newly listed.
+   */
+  enableTools(selection) {
+    const cat = this.catalogue();
+    const { tools, toolsets } = this.checkSelection(cat, selection);
+    const before = new Set(this.listed(cat).map((t) => t.name));
+    for (const name of toolsets) this.enabledSets.add(name);
+    for (const name of tools) this.enabledTools.add(name);
+    this.changed();
+    return this.listed(cat).map((t) => t.name).filter((name) => !before.has(name));
+  }
+  /** Stops listing tools in a discovery view, as `disable_tools` does. Returns the tool names no longer listed. */
+  disableTools(selection) {
+    const cat = this.catalogue();
+    const { tools, toolsets } = this.checkSelection(cat, selection);
+    const before = this.listed(cat).map((t) => t.name);
+    for (const name of toolsets) {
+      this.enabledSets.delete(name);
+      for (const tool of _nullishCoalesce(_optionalChain([cat, 'access', _3 => _3.sets, 'access', _4 => _4.find, 'call', _5 => _5((s) => s.name === name), 'optionalAccess', _6 => _6.tools]), () => ( []))) this.enabledTools.delete(tool);
+    }
+    for (const name of tools) this.enabledTools.delete(name);
+    this.changed();
+    const after = new Set(this.listed(cat).map((t) => t.name));
+    return before.filter((name) => !after.has(name));
+  }
+  /** Allowed toolsets, each with only its allowed tools. */
+  toolsets() {
+    return this.catalogue().sets;
+  }
+  listTools() {
+    const cat = this.catalogue();
+    return { tools: [...this.meta.map(toDefinition), ...this.listed(cat)] };
+  }
+  hasTool(name) {
+    return this.meta.some((t) => t.name === name) || this.find(this.catalogue(), name).found !== void 0;
+  }
+  getTool(name) {
+    const meta = this.meta.find((t) => t.name === name);
+    if (meta) return toDefinition(meta);
+    return this.find(this.catalogue(), name).found;
+  }
+  async callTool(name, args = {}, options = {}) {
+    const meta = this.meta.find((t) => t.name === name);
+    if (meta) {
+      const details = _chunkWOFXZ3XUcjs.validateJsonSchema.call(void 0, _nullishCoalesce(args, () => ( {})), meta.inputSchema);
+      if (details.length > 0) {
+        return errorResult({ code: "invalid_arguments", message: `Invalid arguments for tool "${name}".`, tool: name, details });
+      }
+      try {
+        return toToolResult(await meta.handler(_nullishCoalesce(args, () => ( {})), { name, providerId: "discovery", signal: options.signal }));
+      } catch (error) {
+        return errorResult({ code: "tool_failed", message: error instanceof Error ? error.message : String(error), tool: name });
+      }
+    }
+    const cat = this.catalogue();
+    const match = this.find(cat, name);
+    if (match.found) return this.source.callTool(match.found.name, args, options);
+    return errorResult({ code: "unknown_tool", message: match.message, tool: name });
+  }
+  onListChanged(listener) {
+    if (this.listeners.size === 0) {
+      this.lastSignature = this.signature();
+      this.unsubscribe = this.source.onListChanged(() => this.changed());
+    }
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) {
+        _optionalChain([this, 'access', _7 => _7.unsubscribe, 'optionalCall', _8 => _8()]);
+        this.unsubscribe = null;
+      }
+    };
+  }
+  /** Stops following the source and drops every listener. */
+  dispose() {
+    _optionalChain([this, 'access', _9 => _9.unsubscribe, 'optionalCall', _10 => _10()]);
+    this.unsubscribe = null;
+    this.listeners.clear();
+  }
+  changed() {
+    if (this.listeners.size === 0) return;
+    const signature = this.signature();
+    if (signature === this.lastSignature) return;
+    this.lastSignature = signature;
+    const { tools } = this.listTools();
+    for (const listener of Array.from(this.listeners)) listener(tools);
+  }
+  signature() {
+    return JSON.stringify(this.listTools().tools);
+  }
+  allowsSet(set) {
+    const allow = this.allow;
+    if (!allow) return true;
+    return typeof allow === "function" ? allow(set) : allow.includes(set.name);
+  }
+  catalogue() {
+    const defs = new Map(this.source.listTools().tools.map((t) => [t.name, t]));
+    const tools = [];
+    const sets = [];
+    const setOf = /* @__PURE__ */ new Map();
+    for (const set of this.source.toolsets()) {
+      if (!this.allowsSet(set)) continue;
+      const names = set.tools.filter((name) => {
+        const def = defs.get(name);
+        return def !== void 0 && (!this.readOnly || _optionalChain([def, 'access', _11 => _11.annotations, 'optionalAccess', _12 => _12.readOnlyHint]) === true);
+      });
+      if (names.length === 0) continue;
+      const allowed = { ...set, tools: names };
+      sets.push(allowed);
+      for (const name of names) setOf.set(name, allowed);
+    }
+    for (const def of defs.values()) if (setOf.has(def.name)) tools.push(def);
+    return { tools, sets, setOf };
+  }
+  listed(cat) {
+    if (!this.discovery) return cat.tools;
+    return cat.tools.filter((t) => this.enabledTools.has(t.name) || this.enabledSets.has(cat.setOf.get(t.name).name));
+  }
+  /** Resolves an exposed or unique bare name among the allowed tools, or explains why it isn't one. */
+  find(cat, name) {
+    const exact = cat.tools.find((t) => t.name === name);
+    if (exact) return { found: exact };
+    const bare = cat.tools.filter((t) => baseToolName(t.name) === name);
+    if (bare.length === 1) return { found: bare[0] };
+    if (bare.length > 1) return { message: unknownToolMessage(name, bare.map((t) => t.name)) };
+    const hidden = this.source.getTool(name);
+    if (hidden) {
+      const set = this.source.toolsets().find((s) => s.tools.includes(hidden.name));
+      const reason = set && !this.allowsSet(set) ? `its toolset "${set.name}" is not available to this agent` : "it changes content and this agent has read-only access";
+      return { message: `Tool "${name}" is not available: ${reason}.` };
+    }
+    const hint = this.discovery ? " Call search_tools to find the right tool." : "";
+    return { message: `${unknownToolMessage(name)}${hint}` };
+  }
+  /** Normalizes names to exposed tool and toolset names, or throws naming every unknown one. */
+  checkSelection(cat, selection) {
+    const tools = [];
+    const errors = [];
+    for (const name of _nullishCoalesce(selection.tools, () => ( []))) {
+      const match = this.find(cat, name);
+      if (match.found) tools.push(match.found.name);
+      else errors.push(match.message);
+    }
+    const toolsets = [];
+    for (const name of _nullishCoalesce(selection.toolsets, () => ( []))) {
+      if (cat.sets.some((s) => s.name === name)) toolsets.push(name);
+      else errors.push(`Unknown toolset "${name}".`);
+    }
+    if (errors.length > 0) {
+      throw new Error(`${errors.join(" ")} Nothing was changed. Call list_toolsets or search_tools for valid names.`);
+    }
+    if (tools.length === 0 && toolsets.length === 0) {
+      throw new Error("Pass at least one name in `tools` or `toolsets`.");
+    }
+    return { tools, toolsets };
+  }
+  createDiscoveryTools() {
+    const discovery = this.discovery;
+    const limit = Math.min(Math.max(1, _nullishCoalesce(discovery.searchLimit, () => ( 10))), 50);
+    const skills = discovery.skills ? listSkills(discovery.skills) : [];
+    const enabledState = (set) => {
+      if (this.enabledSets.has(set.name)) return "all";
+      return set.tools.some((t) => this.enabledTools.has(t)) ? "some" : "none";
+    };
+    const listedCount = () => this.listed(this.catalogue()).length;
+    const tools = [
+      {
+        name: "list_toolsets",
+        title: "List toolsets",
+        description: "Lists the groups of editor tools available here (one per open editor or feature): name, title, what it covers, its agent skill, how many tools it has and whether they are in your tool list (`enabled`: all, some or none). Start here, then call search_tools or enable_tools.",
+        annotations: READ_ONLY,
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        handler: () => {
+          const cat = this.catalogue();
+          return {
+            toolsets: cat.sets.map((set) => ({
+              name: set.name,
+              ...set.title ? { title: set.title } : {},
+              ...set.description ? { description: set.description } : {},
+              ...set.skill ? { skill: set.skill } : {},
+              tools: set.tools.length,
+              enabled: enabledState(set)
+            })),
+            ...skills.length > 0 ? { skills: skills.map((s) => s.name) } : {}
+          };
+        }
+      },
+      {
+        name: "search_tools",
+        title: "Search tools",
+        description: `Finds tools for a task across every toolset, best match first: name, toolset, title, a one-sentence summary, whether it only reads, and whether it is in your tool list. Describe the task in a few words ("add a trendline", "remove background noise from audio"). Call enable_tools with the names you need, then call them.`,
+        annotations: READ_ONLY,
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", minLength: 1, description: "What you want to do, in plain words or likely tool-name words." },
+            toolset: { type: "string", minLength: 1, description: "Only search this toolset (a name from list_toolsets). Default: all toolsets." },
+            limit: { type: "integer", minimum: 1, maximum: 50, description: `Maximum number of results. Default: ${limit}.` }
+          },
+          required: ["query"],
+          additionalProperties: false
+        },
+        handler: (args) => {
+          const cat = this.catalogue();
+          if (args.toolset !== void 0 && !cat.sets.some((s) => s.name === args.toolset)) {
+            throw new Error(`Unknown toolset "${args.toolset}". Call list_toolsets for the names.`);
+          }
+          const listed = new Set(this.listed(cat).map((t) => t.name));
+          const results = searchTools(cat.tools, cat.sets, args.query, { toolset: args.toolset, limit: _nullishCoalesce(args.limit, () => ( limit)) }).map(
+            (r) => ({ ...r, enabled: listed.has(r.name) })
+          );
+          return {
+            results,
+            ...results.length === 0 ? { hint: "No tool matched. Try other words, or call list_toolsets." } : {},
+            ...results.some((r) => !r.enabled) ? { next: "Call enable_tools with the names you need; they are then added to your tool list." } : {}
+          };
+        }
+      },
+      {
+        name: "enable_tools",
+        title: "Enable tools",
+        description: "Adds tools to your tool list: single tools by name (from search_tools) and/or whole toolsets (from list_toolsets). Returns the names added and how many tools are listed now. Prefer single tools over large toolsets. Unknown names fail and change nothing.",
+        annotations: LISTING,
+        inputSchema: SELECTION_SCHEMA,
+        handler: (args) => {
+          const added = this.enableTools(args);
+          return { added, listed: listedCount() };
+        }
+      },
+      {
+        name: "disable_tools",
+        title: "Disable tools",
+        description: "Removes tools you no longer need from your tool list, by name and/or whole toolset, to keep it short. They can still be enabled again. Returns the names removed and how many tools are listed now.",
+        annotations: LISTING,
+        inputSchema: SELECTION_SCHEMA,
+        handler: (args) => {
+          const removed = this.disableTools(args);
+          return { removed, listed: listedCount() };
+        }
+      }
+    ];
+    if (skills.length > 0) {
+      tools.push({
+        name: "get_skill",
+        title: "Get skill",
+        description: "Reads an agent skill: the guide to a toolset's tools (when to use each, the working method, pitfalls). Read the skill a toolset names in list_toolsets before working with it. Returns markdown; pass `file` for one of its reference files.",
+        annotations: READ_ONLY,
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", enum: skills.map((s) => s.name), description: "Skill name, as list_toolsets reports it." },
+            file: { type: "string", minLength: 1, description: 'A reference file of the skill, e.g. "references/commands.md". Default: the skill itself (SKILL.md).' }
+          },
+          required: ["name"],
+          additionalProperties: false
+        },
+        handler: (args) => {
+          const skill = skills.find((s) => s.name === args.name);
+          const file = _nullishCoalesce(args.file, () => ( "SKILL.md"));
+          const text = readSkillFile(discovery.skills, skill.name, file);
+          if (text === void 0) {
+            const files = skill.references.length ? ` Its files: ${skill.references.join(", ")}.` : " It has no reference files.";
+            throw new Error(`Skill "${skill.name}" has no file "${file}".${files}`);
+          }
+          const sets = this.catalogue().sets.filter((s) => s.skill === skill.name);
+          const prefixed = sets.filter((s) => s.tools.some((t) => t.startsWith(`${s.name}__`)));
+          const notes = [];
+          if (prefixed.length > 0) {
+            notes.push(
+              `> Tool names in this skill are bare. Here they are prefixed by toolset: ${prefixed.map((s) => `\`${s.name}__\``).join(", ")} (e.g. \`${prefixed[0].tools[0]}\`). A bare name also works when only one toolset has it.`
+            );
+          }
+          if (file === "SKILL.md" && skill.references.length > 0) {
+            notes.push(`> Reference files (call get_skill with \`file\`): ${skill.references.join(", ")}.`);
+          }
+          return {
+            content: [{ type: "text", text: notes.length ? `${notes.join("\n")}
+
+${text}` : text }],
+            structuredContent: { name: skill.name, file, toolsets: sets.map((s) => s.name), references: skill.references }
+          };
+        }
+      });
+    }
+    return tools;
+  }
+}, _class);
+function toDefinition(tool) {
+  const { handler: _handler, ...rest } = tool;
+  return rest;
+}
+
+// src/tools/registry.ts
+var ToolRegistryError = class extends Error {
+  
+  constructor(code, message) {
+    super(message);
+    this.name = "ToolRegistryError";
+    this.code = code;
+  }
+};
+var TOOL_NAMESPACE_SEPARATOR = "__";
+var TOOL_NAME_REGEX = /^[A-Za-z0-9_.-]{1,128}$/;
+var sanitizeNamespace = (id) => id.replace(/[^A-Za-z0-9_-]/g, "_");
+function toolsetName(provider) {
+  return sanitizeNamespace(provider.namespace || provider.id);
+}
+function baseToolName(name) {
+  const index = name.lastIndexOf(TOOL_NAMESPACE_SEPARATOR);
+  return index === -1 ? name : name.slice(index + TOOL_NAMESPACE_SEPARATOR.length);
+}
+function lookup(tools, name) {
+  const exact = tools.find((t) => t.name === name);
+  if (exact) return { found: exact };
+  const candidates = tools.filter((t) => baseToolName(t.name) === name);
+  if (candidates.length === 1) return { found: candidates[0] };
+  return { candidates: candidates.map((t) => t.name) };
+}
+function unknownToolMessage(name, candidates = []) {
+  return candidates.length > 1 ? `Tool "${name}" is ambiguous: ${candidates.map((c) => `"${c}"`).join(", ")} all have that name. Call one of them by its full name.` : `Unknown tool "${name}". List the tools again; the editor that had it may have closed or become read-only.`;
+}
+function readTools(provider) {
+  return typeof provider.tools === "function" ? provider.tools() : provider.tools;
+}
+function toDefinition2(name, tool) {
+  const { handler: _handler, name: _name, ...rest } = tool;
+  return { name, ...rest };
+}
+function errorResult(error) {
+  const details = _optionalChain([error, 'access', _13 => _13.details, 'optionalAccess', _14 => _14.length]) ? "\n" + error.details.map((d) => `- ${d.path}: ${d.message}`).join("\n") : "";
+  return {
+    isError: true,
+    content: [{ type: "text", text: `${error.message}${details}` }],
+    structuredContent: { error }
+  };
+}
+function toToolResult(value) {
+  if (value && typeof value === "object" && Array.isArray(value.content)) {
+    return value;
+  }
+  if (value === void 0) return { content: [] };
+  if (typeof value === "string") return { content: [{ type: "text", text: value }] };
+  const text = JSON.stringify(value);
+  const isPlainObject = typeof value === "object" && value !== null && !Array.isArray(value);
+  return {
+    content: [{ type: "text", text: _nullishCoalesce(text, () => ( String(value))) }],
+    ...isPlainObject ? { structuredContent: value } : {}
+  };
+}
+var ToolRegistry = (_class2 = class {
+  /** MCP server capabilities this registry supports. */
+  __init7() {this.capabilities = { tools: { listChanged: true } }}
+  __init8() {this.entries = []}
+  __init9() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  __init10() {this.timer = null}
+  
+  constructor(options = {}) {;_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+    this.options = {
+      namespaces: _nullishCoalesce(options.namespaces, () => ( "always")),
+      onCollision: _nullishCoalesce(options.onCollision, () => ( "namespace")),
+      listChangedDelayMs: _nullishCoalesce(options.listChangedDelayMs, () => ( 0)),
+      validateArguments: _nullishCoalesce(options.validateArguments, () => ( true))
+    };
+    this.lastSignature = this.signature();
+  }
+  /**
+   * Registers a provider and returns a function that unregisters it.
+   * Throws a {@link ToolRegistryError} for a duplicate provider id, an invalid
+   * tool name, or (with `onCollision: 'error'`) a tool name collision.
+   */
+  register(provider) {
+    if (this.entries.some((e) => e.provider.id === provider.id)) {
+      throw new ToolRegistryError("duplicate_provider", `Tool provider "${provider.id}" is already registered.`);
+    }
+    for (const tool of readTools(provider)) {
+      if (!TOOL_NAME_REGEX.test(tool.name)) {
+        throw new ToolRegistryError("invalid_tool", `Invalid tool name "${tool.name}" from provider "${provider.id}".`);
+      }
+    }
+    const entry = { provider };
+    this.entries.push(entry);
+    try {
+      const names = this.resolve(this.options.onCollision === "error").map((t) => t.name);
+      const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+      if (duplicate) {
+        throw new ToolRegistryError("name_collision", `Tool name "${duplicate}" is exposed more than once.`);
+      }
+    } catch (error) {
+      this.entries.pop();
+      throw error;
+    }
+    if (provider.subscribe) {
+      entry.unsubscribe = provider.subscribe(() => this.notifyListChanged());
+    }
+    this.notifyListChanged();
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      this.unregister(provider);
+    };
+  }
+  /** Removes a provider by id or instance. Returns whether it was registered. */
+  unregister(providerOrId) {
+    const index = this.entries.findIndex(
+      (e) => typeof providerOrId === "string" ? e.provider.id === providerOrId : e.provider === providerOrId
+    );
+    if (index === -1) return false;
+    const [entry] = this.entries.splice(index, 1);
+    _optionalChain([entry, 'access', _15 => _15.unsubscribe, 'optionalCall', _16 => _16()]);
+    this.notifyListChanged();
+    return true;
+  }
+  /** Registered provider ids in registration order. */
+  providerIds() {
+    return this.entries.map((e) => e.provider.id);
+  }
+  /**
+   * Resolves exposed names. Tools are ordered by provider registration, then
+   * by their order within the provider.
+   */
+  resolve(throwOnCollision = false) {
+    const all = [];
+    const counts = /* @__PURE__ */ new Map();
+    const fixed = (provider) => provider.namespace ? provider.namespace : provider.namespace === void 0 && this.options.namespaces === "always" ? provider.id : void 0;
+    for (const { provider } of this.entries) {
+      const prefixed = fixed(provider) !== void 0;
+      for (const tool of readTools(provider)) {
+        all.push({ name: tool.name, tool, provider });
+        if (!prefixed) counts.set(tool.name, (_nullishCoalesce(counts.get(tool.name), () => ( 0))) + 1);
+      }
+    }
+    for (const item of all) {
+      const explicit = fixed(item.provider);
+      const prefix = _nullishCoalesce(explicit, () => ( ((_nullishCoalesce(counts.get(item.name), () => ( 0))) > 1 ? item.provider.id : void 0)));
+      if (prefix !== void 0) {
+        if (throwOnCollision && explicit === void 0) {
+          throw new ToolRegistryError(
+            "name_collision",
+            `Tool "${item.name}" from provider "${item.provider.id}" collides with another provider's tool.`
+          );
+        }
+        item.name = `${sanitizeNamespace(prefix)}${TOOL_NAMESPACE_SEPARATOR}${item.name}`;
+      }
+    }
+    return all;
+  }
+  /** MCP `tools/list` result for the current providers. */
+  listTools() {
+    return { tools: this.resolve().map(({ name, tool }) => toDefinition2(name, tool)) };
+  }
+  /** Whether a tool with this exposed name (or unique bare name) exists. */
+  hasTool(name) {
+    return lookup(this.resolve(), name).found !== void 0;
+  }
+  /** Looks up a tool definition by exposed name (or unique bare name). */
+  getTool(name) {
+    const { found } = lookup(this.resolve(), name);
+    return found ? toDefinition2(found.name, found.tool) : void 0;
+  }
+  /** The registered providers grouped by namespace, in listing order. */
+  toolsets() {
+    const sets = /* @__PURE__ */ new Map();
+    for (const { name, provider } of this.resolve()) {
+      const key = toolsetName(provider);
+      let set = sets.get(key);
+      if (!set) {
+        set = { name: key, providers: [], tools: [] };
+        sets.set(key, set);
+      }
+      if (!set.providers.includes(provider.id)) set.providers.push(provider.id);
+      set.title ??= provider.title;
+      set.description ??= provider.description;
+      set.skill ??= provider.skill;
+      set.tools.push(name);
+    }
+    return Array.from(sets.values(), (set) => ({
+      name: set.name,
+      ...set.title ? { title: set.title } : {},
+      ...set.description ? { description: set.description } : {},
+      ...set.skill ? { skill: set.skill } : {},
+      providers: set.providers,
+      tools: set.tools
+    }));
+  }
+  /**
+   * A filtered, optionally self-discovering view of this registry: serve it
+   * with `createMcpServer` or `connectToolBridge` instead of the registry to
+   * show an agent only some toolsets. See {@link ToolRegistryView}.
+   */
+  view(options = {}) {
+    return new ToolRegistryView(this, options);
+  }
+  /**
+   * Calls a tool by exposed name and returns an MCP `tools/call` result.
+   * Never rejects: unknown tools, invalid arguments and handler errors come
+   * back as `isError: true` results with a {@link ToolCallError} in
+   * `structuredContent.error` (MCP transports may map `unknown_tool` to a
+   * JSON-RPC `-32602` error instead).
+   */
+  async callTool(name, args = {}, options = {}) {
+    const match = lookup(this.resolve(), name);
+    const found = match.found;
+    if (!found) {
+      return errorResult({ code: "unknown_tool", message: unknownToolMessage(name, match.candidates), tool: name });
+    }
+    name = found.name;
+    const input = _nullishCoalesce(args, () => ( {}));
+    if (this.options.validateArguments) {
+      const details = _chunkWOFXZ3XUcjs.validateJsonSchema.call(void 0, input, found.tool.inputSchema);
+      if (details.length > 0) {
+        return errorResult({
+          code: "invalid_arguments",
+          message: `Invalid arguments for tool "${name}".`,
+          tool: name,
+          details
+        });
+      }
+    }
+    try {
+      const value = await found.tool.handler(input, {
+        name,
+        providerId: found.provider.id,
+        signal: options.signal
+      });
+      return toToolResult(value);
+    } catch (error) {
+      return errorResult({
+        code: "tool_failed",
+        message: error instanceof Error ? error.message : String(error),
+        tool: name
+      });
+    }
+  }
+  /**
+   * Subscribes to tool-list changes. Notifications are coalesced: many
+   * registrations or provider signals within the delay window produce one
+   * call, and none if the exposed list ends up unchanged (e.g. a provider
+   * unmounted and remounted). Returns an unsubscribe function.
+   */
+  onListChanged(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Schedules a coalesced `listChanged` check; providers may call it directly. */
+  notifyListChanged() {
+    if (this.timer !== null) return;
+    this.timer = setTimeout(() => this.flush(), this.options.listChangedDelayMs);
+  }
+  /** Runs a pending `listChanged` check immediately. */
+  flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const signature = this.signature();
+    if (signature === this.lastSignature) return;
+    this.lastSignature = signature;
+    const { tools } = this.listTools();
+    for (const listener of Array.from(this.listeners)) listener(tools);
+  }
+  signature() {
+    try {
+      return JSON.stringify(this.listTools().tools);
+    } catch (e2) {
+      return String(Math.random());
+    }
+  }
+  /** Unregisters every provider and listener and cancels pending notifications. */
+  dispose() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    for (const entry of this.entries.splice(0)) _optionalChain([entry, 'access', _17 => _17.unsubscribe, 'optionalCall', _18 => _18()]);
+    this.listeners.clear();
+  }
+}, _class2);
+function createToolRegistry(options) {
+  return new ToolRegistry(options);
+}
+
+// src/tools/search.ts
+var STOP_WORDS = new Set(
+  "a an and are as at be by can do for from has have how i in into is it its me my of on or our so than that the their them then there these this to up us use using want we what when which will with you your please make let".split(
+    " "
+  )
+);
+function stem(word) {
+  if (word.length > 5 && word.endsWith("ing")) return word.slice(0, -3);
+  if (word.length > 4 && word.endsWith("ies")) return `${word.slice(0, -3)}y`;
+  if (word.length > 4 && word.endsWith("ed")) return word.slice(0, -2);
+  if (word.length > 4 && word.endsWith("es") && /(ch|sh|x|ss)es$/.test(word)) return word.slice(0, -2);
+  if (word.length > 2 && word.endsWith("s") && !/(ss|us|is|as)$/.test(word)) return word.slice(0, -1);
+  return word;
+}
+var SPELLING = { colour: "color", grey: "gray", centre: "center", organise: "organize", normalise: "normalize" };
+var SYNONYMS = {
+  link: ["connect", "edge"],
+  join: ["connect", "merge"],
+  arrow: ["edge", "connect"],
+  step: ["node"],
+  box: ["node", "shape"],
+  flowchart: ["diagram"],
+  graph: ["chart", "diagram"],
+  plot: ["chart"],
+  photo: ["image"],
+  picture: ["image"],
+  footage: ["video", "clip"],
+  timeline: ["track", "clip", "video"],
+  recording: ["audio", "video"],
+  sound: ["audio"],
+  quiet: ["silence"],
+  silent: ["silence"],
+  delete: ["remove"],
+  erase: ["remove", "clear"],
+  screenshot: ["capture", "view"],
+  snapshot: ["capture"],
+  tidy: ["layout", "arrange"],
+  arrange: ["layout"],
+  organize: ["layout", "arrange"],
+  number: ["value", "data"],
+  figure: ["value", "data"],
+  cost: ["estimate", "credit"],
+  price: ["estimate", "credit"],
+  version: ["vary", "variation"],
+  variation: ["vary"],
+  illustration: ["vector", "art"],
+  svg: ["vector"],
+  space: ["gap"],
+  empty: ["gap"],
+  blemish: ["heal", "spot"],
+  tonal: ["histogram"],
+  tone: ["histogram", "level"],
+  um: ["filler"],
+  uh: ["filler"],
+  dissolve: ["transition"],
+  crossfade: ["transition"],
+  wipe: ["transition"],
+  mark: ["marker"],
+  timelapse: ["time", "lapse"],
+  brightness: ["adjustment", "exposure"],
+  brighter: ["adjustment", "exposure"],
+  contrast: ["adjustment"],
+  shadow: ["effect"],
+  glow: ["effect"],
+  grain: ["effect", "paper"],
+  look: ["grade", "preset"],
+  cinematic: ["grade", "lut"],
+  save: ["export"],
+  find: ["search"],
+  search: ["find"],
+  change: ["update", "set", "edit"],
+  menu: ["command"],
+  action: ["command"],
+  shortcut: ["command"]
+};
+function searchTokens(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1 && !STOP_WORDS.has(w)).map((w) => {
+    const stemmed = stem(w);
+    return _nullishCoalesce(SPELLING[stemmed], () => ( stemmed));
+  });
+}
+function summarize(description, max = 200) {
+  if (!description) return "";
+  const match = /^[\s\S]*?[.!?](?=\s|$)/.exec(description.trim());
+  const sentence = (match ? match[0] : description.trim()).replace(/\s+/g, " ");
+  return sentence.length > max ? `${sentence.slice(0, max - 1)}\u2026` : sentence;
+}
+var COMMON_VERBS = /* @__PURE__ */ new Set(["add", "set", "get", "remove", "list", "update", "change", "make", "create", "delete", "read", "show", "put", "use", "edit"]);
+var WEIGHTS = { name: 4, title: 2.5, toolset: 1.5, description: 1, params: 0.5 };
+function paramText(schema, depth = 0) {
+  if (!schema || typeof schema !== "object" || depth > 2) return "";
+  const s = schema;
+  const parts = [];
+  if (typeof s.description === "string" && depth > 0) parts.push(s.description);
+  if (Array.isArray(s.enum)) parts.push(s.enum.filter((v) => typeof v === "string").join(" "));
+  for (const [key, value] of Object.entries(_nullishCoalesce(s.properties, () => ( {})))) parts.push(key, paramText(value, depth + 1));
+  if (s.items) parts.push(paramText(s.items, depth + 1));
+  if (Array.isArray(s.anyOf)) for (const branch of s.anyOf) parts.push(paramText(branch, depth + 1));
+  return parts.join(" ");
+}
+function document(tool, toolset) {
+  const fields = {
+    name: new Set(searchTokens(baseToolName(tool.name))),
+    title: new Set(searchTokens(_nullishCoalesce(_nullishCoalesce(tool.title, () => ( _optionalChain([tool, 'access', _19 => _19.annotations, 'optionalAccess', _20 => _20.title]))), () => ( "")))),
+    toolset: new Set(searchTokens(`${toolset.name} ${_nullishCoalesce(toolset.title, () => ( ""))} ${_nullishCoalesce(toolset.description, () => ( ""))}`)),
+    description: new Set(searchTokens(_nullishCoalesce(tool.description, () => ( "")))),
+    params: new Set(searchTokens(paramText(tool.inputSchema)))
+  };
+  const all = /* @__PURE__ */ new Set();
+  for (const set of Object.values(fields)) for (const t of set) all.add(t);
+  return { tool, toolset, fields, all };
+}
+function matchValue(tokens, word, alternatives, idf) {
+  const rarity = _nullishCoalesce(idf.get(word), () => ( 1));
+  if (tokens.has(word)) return rarity;
+  let value = 0;
+  if (word.length >= 4) {
+    for (const t of tokens) {
+      if (t.startsWith(word) || t.length >= 4 && word.startsWith(t)) {
+        value = rarity / 2;
+        break;
+      }
+    }
+  }
+  for (const alt of alternatives) {
+    if (tokens.has(alt)) value = Math.max(value, Math.min(rarity, _nullishCoalesce(idf.get(alt), () => ( 1))) / 2);
+  }
+  return value;
+}
+function searchTools(tools, toolsets, query, options = {}) {
+  const setOf = /* @__PURE__ */ new Map();
+  for (const set of toolsets) for (const name of set.tools) setOf.set(name, set);
+  const docs = tools.flatMap((tool) => {
+    const set = _nullishCoalesce(setOf.get(tool.name), () => ( { name: "", providers: [], tools: [tool.name] }));
+    return !options.toolset || set.name === options.toolset ? [document(tool, set)] : [];
+  });
+  const words = Array.from(new Set(searchTokens(query)));
+  if (words.length === 0 || docs.length === 0) return [];
+  const alternatives = new Map(words.map((w) => [w, (_nullishCoalesce(SYNONYMS[w], () => ( []))).map(stem)]));
+  const all = options.toolset ? tools.map((t) => document(t, _nullishCoalesce(setOf.get(t.name), () => ( { name: "", providers: [], tools: [] })))) : docs;
+  const idf = /* @__PURE__ */ new Map();
+  for (const word of [...words, ...[...alternatives.values()].flat()]) {
+    if (idf.has(word)) continue;
+    const df = all.filter((d) => d.all.has(word)).length;
+    idf.set(word, Math.log(1 + all.length / (1 + df)));
+  }
+  const phrase = query.trim().toLowerCase().replace(/\s+/g, "_");
+  const results = [];
+  for (const doc of docs) {
+    let score = 0;
+    let matched = 0;
+    for (const word of words) {
+      let best = 0;
+      for (const field of Object.keys(WEIGHTS)) {
+        const weight = COMMON_VERBS.has(word) ? Math.min(WEIGHTS[field], WEIGHTS.description) : WEIGHTS[field];
+        const value = matchValue(doc.fields[field], word, _nullishCoalesce(alternatives.get(word), () => ( [])), idf) * weight;
+        best = Math.max(best, value);
+        score += value * 0.1;
+      }
+      if (best > 0) matched++;
+      score += best;
+    }
+    if (matched === 0) continue;
+    score *= 0.5 + 0.5 * matched / words.length;
+    const base = baseToolName(doc.tool.name);
+    if (base === phrase || doc.tool.name === phrase) score *= 3;
+    results.push({
+      name: doc.tool.name,
+      toolset: doc.toolset.name,
+      ...doc.tool.title ? { title: doc.tool.title } : {},
+      summary: summarize(doc.tool.description),
+      readOnly: _optionalChain([doc, 'access', _21 => _21.tool, 'access', _22 => _22.annotations, 'optionalAccess', _23 => _23.readOnlyHint]) === true,
+      score: Math.round(score * 100) / 100
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, _nullishCoalesce(options.limit, () => ( 10)));
+}
+
+// src/tools/mcp-server.ts
+var MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var JSON_RPC_ERRORS = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603
+};
+var errorResponse = (id, code, message, data) => ({
+  jsonrpc: "2.0",
+  id,
+  error: { code, message, ...data !== void 0 ? { data } : {} }
+});
+function toolsetInstructions(source) {
+  const sets = source.toolsets();
+  const discovery = source.hasTool("list_toolsets") && source.hasTool("search_tools");
+  const lines = [
+    "Tools are grouped into toolsets, one per open editor or feature, and named `<toolset>__<tool>`." + (discovery ? " Only some are listed at first: call list_toolsets to see them all, search_tools to find a tool for a task, and enable_tools to add what you need." : "")
+  ];
+  if (sets.length > 0) {
+    lines.push("", "Toolsets:");
+    for (const set of sets) {
+      const about = [set.title, summarize(set.description)].filter(Boolean).join(": ");
+      const skill = set.skill ? ` (skill: ${set.skill})` : "";
+      lines.push(`- ${set.name}${about ? ` - ${about}` : ""}${skill}, ${set.tools.length} tools`);
+    }
+  }
+  if (sets.some((s) => s.skill)) {
+    lines.push(
+      "",
+      "Read the skill a toolset names before using it" + (source.hasTool("get_skill") ? " (get_skill)." : " (an MCP resource or prompt when the server offers skills).")
+    );
+  }
+  return lines.join("\n");
+}
+var skillUri = (path) => `skill://${path}`;
+function createMcpServer(registry, options) {
+  const skillFiles = _nullishCoalesce(options.skills, () => ( null));
+  const skills = skillFiles ? listSkills(skillFiles) : [];
+  const capabilities = {
+    ...registry.capabilities,
+    ...skills.length > 0 ? { resources: {}, prompts: {} } : {}
+  };
+  const readSkillPath = (path) => _nullishCoalesce(_optionalChain([skillFiles, 'optionalAccess', _24 => _24[path]]), () => ( _optionalChain([skillFiles, 'optionalAccess', _25 => _25[`./${path}`]])));
+  let initialized = false;
+  let unsubscribe = null;
+  const running = /* @__PURE__ */ new Map();
+  const startNotifications = () => {
+    if (unsubscribe || !options.send) return;
+    const send = options.send;
+    unsubscribe = registry.onListChanged(() => send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }));
+  };
+  async function dispatch(request) {
+    const id = _nullishCoalesce(request.id, () => ( null));
+    const isNotification = request.id === void 0 || request.id === null;
+    const params = _nullishCoalesce(request.params, () => ( {}));
+    switch (request.method) {
+      case "initialize": {
+        const instructions = typeof options.instructions === "function" ? options.instructions(registry) : options.instructions;
+        const requested = String(_nullishCoalesce(params.protocolVersion, () => ( "")));
+        const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_PROTOCOL_VERSIONS[0];
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion,
+            capabilities,
+            serverInfo: { name: options.name, version: options.version, ...options.title ? { title: options.title } : {} },
+            ...instructions ? { instructions } : {}
+          }
+        };
+      }
+      case "notifications/initialized":
+        initialized = true;
+        startNotifications();
+        return null;
+      case "notifications/cancelled": {
+        const requestId = params.requestId;
+        if (requestId !== void 0) _optionalChain([running, 'access', _26 => _26.get, 'call', _27 => _27(requestId), 'optionalAccess', _28 => _28.abort, 'call', _29 => _29(params.reason)]);
+        return null;
+      }
+      case "ping":
+        return { jsonrpc: "2.0", id, result: {} };
+      case "tools/list":
+        return { jsonrpc: "2.0", id, result: registry.listTools() };
+      case "tools/call": {
+        const name = params.name;
+        if (typeof name !== "string") {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, 'tools/call needs a string "name".');
+        }
+        if (!registry.hasTool(name)) {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown tool: ${name}`);
+        }
+        const args = params.arguments;
+        if (args !== void 0 && (typeof args !== "object" || args === null || Array.isArray(args))) {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, '"arguments" must be an object.');
+        }
+        const controller = new AbortController();
+        if (!isNotification) running.set(id, controller);
+        try {
+          const result = await registry.callTool(name, _nullishCoalesce(args, () => ( {})), { signal: controller.signal });
+          if (controller.signal.aborted) return null;
+          return { jsonrpc: "2.0", id, result };
+        } finally {
+          if (!isNotification) running.delete(id);
+        }
+      }
+      case "resources/list":
+      case "prompts/list":
+      case "resources/read":
+      case "prompts/get": {
+        if (skills.length === 0) break;
+        if (request.method === "resources/list") {
+          const resources = skills.flatMap(
+            (skill2) => ["SKILL.md", ...skill2.references].map((file) => ({
+              uri: skillUri(`${skill2.name}/${file}`),
+              name: file === "SKILL.md" ? skill2.name : `${skill2.name}/${file}`,
+              ...file === "SKILL.md" ? { description: skill2.description } : {},
+              mimeType: "text/markdown"
+            }))
+          );
+          return { jsonrpc: "2.0", id, result: { resources } };
+        }
+        if (request.method === "resources/read") {
+          const uri = String(_nullishCoalesce(params.uri, () => ( "")));
+          const text2 = uri.startsWith("skill://") ? readSkillPath(uri.slice("skill://".length)) : void 0;
+          if (text2 === void 0) return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown resource: ${uri}`, { uri });
+          return { jsonrpc: "2.0", id, result: { contents: [{ uri, mimeType: "text/markdown", text: text2 }] } };
+        }
+        if (request.method === "prompts/list") {
+          return { jsonrpc: "2.0", id, result: { prompts: skills.map((s) => ({ name: s.name, description: s.description })) } };
+        }
+        const skill = skills.find((s) => s.name === params.name);
+        const text = skill ? readSkillPath(`${skill.name}/SKILL.md`) : void 0;
+        if (!skill || text === void 0) return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown prompt: ${String(params.name)}`);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            description: skill.description,
+            messages: [{ role: "user", content: { type: "text", text: parseSkillFrontmatter(text).body.trim() } }]
+          }
+        };
+      }
+    }
+    if (isNotification) return null;
+    return errorResponse(id, JSON_RPC_ERRORS.methodNotFound, `Method not found: ${request.method}`);
+  }
+  return {
+    get initialized() {
+      return initialized;
+    },
+    async handle(message) {
+      let request;
+      if (typeof message === "string") {
+        try {
+          request = JSON.parse(message);
+        } catch (e3) {
+          return errorResponse(null, JSON_RPC_ERRORS.parseError, "Parse error.");
+        }
+      } else {
+        request = message;
+      }
+      if (!request || typeof request !== "object" || Array.isArray(request) || request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+        const id = request && typeof request === "object" && !Array.isArray(request) ? _nullishCoalesce(request.id, () => ( null)) : null;
+        return errorResponse(id, JSON_RPC_ERRORS.invalidRequest, "Invalid JSON-RPC 2.0 request.");
+      }
+      try {
+        return await dispatch(request);
+      } catch (error) {
+        if (request.id === void 0 || request.id === null) return null;
+        return errorResponse(
+          request.id,
+          JSON_RPC_ERRORS.internalError,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    },
+    close() {
+      _optionalChain([unsubscribe, 'optionalCall', _30 => _30()]);
+      unsubscribe = null;
+      for (const controller of running.values()) controller.abort("Server closed.");
+      running.clear();
+    }
+  };
+}
+
+// src/tools/bridge-client.ts
+var TOOL_BRIDGE_PROTOCOL = 1;
+var TOOL_BRIDGE_DEFAULT_PORT = 4477;
+function connectToolBridge(registry, options) {
+  const Ctor = _nullishCoalesce(options.WebSocket, () => ( globalThis.WebSocket));
+  if (!Ctor) throw new Error("No WebSocket implementation: pass options.WebSocket.");
+  const base = _nullishCoalesce(options.url, () => ( `ws://127.0.0.1:${TOOL_BRIDGE_DEFAULT_PORT}`));
+  const url = options.token ? `${base}${base.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.token)}` : base;
+  let status = "connecting";
+  let editorId = null;
+  let socket = null;
+  let closed = false;
+  let delay = 500;
+  let retry = null;
+  const running = /* @__PURE__ */ new Map();
+  const setStatus = (next, detail) => {
+    if (next === status && !detail) return;
+    status = next;
+    _optionalChain([options, 'access', _31 => _31.onStatus, 'optionalCall', _32 => _32(next, detail)]);
+  };
+  const send = (message) => {
+    if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
+  };
+  const unsubscribe = registry.onListChanged((tools) => send({ t: "tools", tools }));
+  const open = () => {
+    if (closed) return;
+    setStatus("connecting");
+    const ws = new Ctor(url);
+    socket = ws;
+    ws.addEventListener("open", () => {
+      delay = 500;
+      send({ t: "hello", v: TOOL_BRIDGE_PROTOCOL, name: options.name, ...options.kind ? { kind: options.kind } : {}, tools: registry.listTools().tools });
+    });
+    ws.addEventListener("message", (event) => {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch (e4) {
+        return;
+      }
+      if (message.t === "welcome") {
+        editorId = message.id;
+        setStatus("connected");
+      } else if (message.t === "call") {
+        const controller = new AbortController();
+        running.set(message.id, controller);
+        void registry.callTool(message.name, _nullishCoalesce(message.arguments, () => ( {})), { signal: controller.signal }).then((result) => {
+          running.delete(message.id);
+          if (!controller.signal.aborted) send({ t: "result", id: message.id, result });
+        });
+      } else if (message.t === "cancel") {
+        _optionalChain([running, 'access', _33 => _33.get, 'call', _34 => _34(message.id), 'optionalAccess', _35 => _35.abort, 'call', _36 => _36(_nullishCoalesce(message.reason, () => ( "Cancelled by the agent.")))]);
+        running.delete(message.id);
+      }
+    });
+    ws.addEventListener("close", (event) => {
+      if (socket !== ws) return;
+      socket = null;
+      editorId = null;
+      for (const controller of running.values()) controller.abort("The bridge disconnected.");
+      running.clear();
+      if (closed) return setStatus("closed");
+      setStatus("disconnected", event.reason || void 0);
+      if (options.reconnect === false) return;
+      retry = setTimeout(open, delay);
+      delay = Math.min(1e4, delay * 2);
+    });
+    ws.addEventListener("error", () => {
+    });
+  };
+  open();
+  return {
+    get status() {
+      return status;
+    },
+    get editorId() {
+      return editorId;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      if (retry) clearTimeout(retry);
+      unsubscribe();
+      for (const controller of running.values()) controller.abort("The editor disconnected.");
+      running.clear();
+      const ws = socket;
+      socket = null;
+      _optionalChain([ws, 'optionalAccess', _37 => _37.close, 'call', _38 => _38(1e3, "Editor closed.")]);
+      setStatus("closed");
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.searchTokens = searchTokens; exports.summarize = summarize; exports.searchTools = searchTools; exports.parseSkillFrontmatter = parseSkillFrontmatter; exports.listSkills = listSkills; exports.readSkillFile = readSkillFile; exports.TOOL_DISCOVERY_TOOLS = TOOL_DISCOVERY_TOOLS; exports.ToolRegistryView = ToolRegistryView; exports.ToolRegistryError = ToolRegistryError; exports.TOOL_NAMESPACE_SEPARATOR = TOOL_NAMESPACE_SEPARATOR; exports.toolsetName = toolsetName; exports.baseToolName = baseToolName; exports.unknownToolMessage = unknownToolMessage; exports.errorResult = errorResult; exports.toToolResult = toToolResult; exports.ToolRegistry = ToolRegistry; exports.createToolRegistry = createToolRegistry; exports.MCP_PROTOCOL_VERSIONS = MCP_PROTOCOL_VERSIONS; exports.JSON_RPC_ERRORS = JSON_RPC_ERRORS; exports.toolsetInstructions = toolsetInstructions; exports.createMcpServer = createMcpServer; exports.TOOL_BRIDGE_PROTOCOL = TOOL_BRIDGE_PROTOCOL; exports.TOOL_BRIDGE_DEFAULT_PORT = TOOL_BRIDGE_DEFAULT_PORT; exports.connectToolBridge = connectToolBridge;