storybook/dist/_node-chunks/chunk-5ZQGOLDE.js

Storybook: Develop, document, and test UI components in isolation

import CJS_COMPAT_NODE_URL_qjinduibsyq from 'node:url';
import CJS_COMPAT_NODE_PATH_qjinduibsyq from 'node:path';
import CJS_COMPAT_NODE_MODULE_qjinduibsyq from "node:module";

var __filename = CJS_COMPAT_NODE_URL_qjinduibsyq.fileURLToPath(import.meta.url);
var __dirname = CJS_COMPAT_NODE_PATH_qjinduibsyq.dirname(__filename);
var require = CJS_COMPAT_NODE_MODULE_qjinduibsyq.createRequire(import.meta.url);

// ------------------------------------------------------------
// end of CJS compatibility banner, injected by Storybook's esbuild configuration
// ------------------------------------------------------------
import {
  toCliMethodName,
  toMcpToolName
} from "./chunk-52XR72NR.js";
import {
  OpenServiceDuplicateToolNameError,
  OpenServiceDuplicateToolsetError,
  OpenServiceInvalidToolsetMethodIdError
} from "./chunk-DW727PJG.js";

// src/shared/open-service/toolset-registry.ts
var TOOLSET_REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("storybook.open-service.toolset-registry");
function getToolsetRegistry() {
  let registryGlobal = globalThis;
  return registryGlobal[TOOLSET_REGISTRY_SYMBOL] ??= /* @__PURE__ */ new Map(), registryGlobal[TOOLSET_REGISTRY_SYMBOL];
}
function assertNoDerivedNameCollisions(toolset) {
  let registry = getToolsetRegistry(), cliNames = /* @__PURE__ */ new Map();
  for (let methodName of Object.keys(toolset.methods)) {
    if (!methodName || methodName.includes("."))
      throw new OpenServiceInvalidToolsetMethodIdError({
        methodId: `${toolset.id}.${methodName}`
      });
    let cliName = toCliMethodName(methodName), priorCli = cliNames.get(cliName);
    if (priorCli)
      throw new OpenServiceDuplicateToolNameError({
        derivedName: cliName,
        first: `${toolset.id}.${priorCli}`,
        second: `${toolset.id}.${methodName}`,
        transport: "cli"
      });
    cliNames.set(cliName, methodName);
    let methodId = `${toolset.id}.${methodName}`, mcpName;
    try {
      mcpName = toMcpToolName(methodId);
    } catch {
      throw new OpenServiceInvalidToolsetMethodIdError({ methodId });
    }
    for (let [existingId, existing] of registry)
      for (let existingMethod of Object.keys(existing.methods)) {
        let existingMethodId = `${existingId}.${existingMethod}`;
        if (toMcpToolName(existingMethodId) === mcpName)
          throw new OpenServiceDuplicateToolNameError({
            derivedName: mcpName,
            first: existingMethodId,
            second: methodId,
            transport: "mcp"
          });
      }
  }
}
function registerToolset(toolset) {
  let registry = getToolsetRegistry();
  if (registry.has(toolset.id))
    throw new OpenServiceDuplicateToolsetError({ toolsetId: toolset.id });
  assertNoDerivedNameCollisions(toolset), registry.set(toolset.id, toolset);
}
function getRegisteredToolsets() {
  return [...getToolsetRegistry().values()];
}
function clearToolsetRegistry() {
  getToolsetRegistry().clear();
}

export {
  registerToolset,
  getRegisteredToolsets,
  clearToolsetRegistry
};