@mcp-layer/gateway 0.1.0

package/src/config/validate.js

@@ -0,0 +1,165 @@
+import { defaults } from './defaults.js';
+import { LayerError } from '@mcp-layer/error';
+
+/**
+ * Test whether a value is a plain object.
+ * @param {unknown} value - Value to test.
+ * @returns {value is Record<string, unknown>}
+ */
+function isrecord(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+/**
+ * Merge a shallow configuration object over defaults.
+ * @param {Record<string, unknown>} base - Default config object.
+ * @param {Record<string, unknown> | undefined} next - Override config object.
+ * @returns {Record<string, unknown>}
+ */
+function merge(base, next) {
+  if (!isrecord(next)) return { ...base };
+  return { ...base, ...next };
+}
+
+/**
+ * Assert that a value is a finite positive number.
+ * @param {string} name - Option name.
+ * @param {unknown} value - Option value.
+ * @param {string} pack - Package identifier for errors.
+ * @returns {number}
+ */
+function requirePositiveNumber(name, value, pack) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+    throw new LayerError({
+      name: pack,
+      method: 'requirePositiveNumber',
+      message: '"{option}" must be a positive number.',
+      vars: { option: name }
+    });
+  }
+  return value;
+}
+
+/**
+ * Validate trustSchemas value.
+ * @param {unknown} value - trustSchemas input.
+ * @param {string} pack - Package identifier for errors.
+ * @returns {'auto' | true | false}
+ */
+function trustMode(value, pack) {
+  if (value === 'auto' || value === true || value === false) return value;
+  throw new LayerError({
+    name: pack,
+    method: 'trustMode',
+    message: 'validation.trustSchemas must be "auto", true, or false.',
+  });
+}
+
+/**
+ * Validate base runtime options and apply defaults.
+ * @param {Record<string, unknown>} opts - User-supplied options.
+ * @param {{ name?: string, serviceName?: string }} [meta] - Validation metadata.
+ * @returns {{ session: unknown, manager?: { get: (request: import('fastify').FastifyRequest) => Promise<import('@mcp-layer/session').Session>, close?: () => Promise<void> }, prefix?: string | ((version: string, info: Record<string, unknown> | undefined, name: string) => string), validation: { trustSchemas: 'auto' | true | false, maxSchemaDepth: number, maxSchemaSize: number, maxPatternLength: number, maxToolNameLength: number, maxTemplateParamLength: number }, resilience: { enabled: boolean, timeout: number, errorThresholdPercentage: number, resetTimeout: number, volumeThreshold: number }, telemetry: { enabled: boolean, serviceName: string, metricPrefix: string, api?: import('@opentelemetry/api') }, errors: { exposeDetails: boolean }, normalizeError?: (error: Error & { code?: string | number }, instance: string, requestId?: string, options?: { exposeDetails?: boolean }) => unknown }}
+ */
+export function validateRuntimeOptions(opts, meta = {}) {
+  const pack = typeof meta.name === 'string' && meta.name.length > 0 ? meta.name : 'gateway';
+  const serviceName = typeof meta.serviceName === 'string' && meta.serviceName.length > 0
+    ? meta.serviceName
+    : 'mcp-layer-gateway';
+  const base = defaults(serviceName);
+  const input = isrecord(opts) ? opts : {};
+  const session = input.session;
+  const manager = input.manager;
+
+  if (!session && !manager) {
+    throw new LayerError({
+      name: pack,
+      method: 'validateRuntimeOptions',
+      message: 'session or manager option is required.',
+    });
+  }
+
+  if (manager !== undefined) {
+    if (!isrecord(manager) || typeof manager.get !== 'function') {
+      throw new LayerError({
+        name: pack,
+        method: 'validateRuntimeOptions',
+        message: 'manager must be an object with a get(request) function.',
+      });
+    }
+    if (!session) {
+      throw new LayerError({
+        name: pack,
+        method: 'validateRuntimeOptions',
+        message: 'session is required when manager is provided (used for catalog bootstrap).',
+      });
+    }
+    if (Array.isArray(session)) {
+      throw new LayerError({
+        name: pack,
+        method: 'validateRuntimeOptions',
+        message: 'manager does not support multiple sessions. Register multiple plugins instead.',
+      });
+    }
+  }
+
+  if (input.prefix !== undefined && typeof input.prefix !== 'string' && typeof input.prefix !== 'function') {
+    throw new LayerError({
+      name: pack,
+      method: 'validateRuntimeOptions',
+      message: 'prefix must be a string or function.',
+    });
+  }
+
+  if (input.errors !== undefined && !isrecord(input.errors)) {
+    throw new LayerError({
+      name: pack,
+      method: 'validateRuntimeOptions',
+      message: 'errors must be an object.',
+    });
+  }
+
+  if (input.validation !== undefined && !isrecord(input.validation)) {
+    throw new LayerError({
+      name: pack,
+      method: 'validateRuntimeOptions',
+      message: 'validation must be an object.',
+    });
+  }
+
+  if (input.normalizeError !== undefined && typeof input.normalizeError !== 'function') {
+    throw new LayerError({
+      name: pack,
+      method: 'validateRuntimeOptions',
+      message: 'normalizeError must be a function.',
+    });
+  }
+
+  const validation = merge(base.validation, input.validation);
+  const resilience = merge(base.resilience, input.resilience);
+  const telemetry = merge(base.telemetry, input.telemetry);
+  const errors = merge(base.errors, input.errors);
+  const normalizedValidation = /** @type {typeof base.validation} */ (validation);
+
+  normalizedValidation.trustSchemas = trustMode(normalizedValidation.trustSchemas, pack);
+  normalizedValidation.maxSchemaDepth = requirePositiveNumber('validation.maxSchemaDepth', normalizedValidation.maxSchemaDepth, pack);
+  normalizedValidation.maxSchemaSize = requirePositiveNumber('validation.maxSchemaSize', normalizedValidation.maxSchemaSize, pack);
+  normalizedValidation.maxPatternLength = requirePositiveNumber('validation.maxPatternLength', normalizedValidation.maxPatternLength, pack);
+  normalizedValidation.maxToolNameLength = requirePositiveNumber('validation.maxToolNameLength', normalizedValidation.maxToolNameLength, pack);
+  normalizedValidation.maxTemplateParamLength = requirePositiveNumber('validation.maxTemplateParamLength', normalizedValidation.maxTemplateParamLength, pack);
+
+  if (typeof telemetry.metricPrefix !== 'string' || telemetry.metricPrefix.length === 0) {
+    telemetry.metricPrefix = base.telemetry.metricPrefix;
+  }
+
+  return {
+    session,
+    manager: /** @type {{ get: (request: import('fastify').FastifyRequest) => Promise<import('@mcp-layer/session').Session>, close?: () => Promise<void> } | undefined} */ (manager),
+    prefix: input.prefix,
+    validation: normalizedValidation,
+    resilience: /** @type {typeof base.resilience} */ (resilience),
+    telemetry: /** @type {typeof base.telemetry} */ (telemetry),
+    errors: /** @type {typeof base.errors} */ (errors),
+    normalizeError: /** @type {((error: Error & { code?: string | number }, instance: string, requestId?: string, options?: { exposeDetails?: boolean }) => unknown) | undefined} */ (input.normalizeError)
+  };
+}

package/src/index.js

@@ -0,0 +1,11 @@
+export { createRuntime } from './runtime.js';
+export { createMap, TYPES } from './map.js';
+export { deriveApiVersion, resolvePrefix } from './version.js';
+export { createCallContext } from './call.js';
+export { createTelemetry } from './telemetry/index.js';
+export { createCircuitBreaker, executeWithBreaker } from './resilience/breaker.js';
+export { createValidator, SchemaValidator } from './validation/validator.js';
+export { shouldTrustSchemas } from './validation/trust.js';
+export { checkSchemaSafety } from './validation/safety.js';
+export { defaults } from './config/defaults.js';
+export { validateRuntimeOptions } from './config/validate.js';

package/src/map.js

@@ -0,0 +1,158 @@
+const TYPES = ['tool', 'prompt', 'resource', 'resource-template'];
+
+/**
+ * Sanitize a raw value into a GraphQL-safe field base.
+ * @param {string} type - Catalog item type.
+ * @param {string} value - Raw field candidate.
+ * @returns {string}
+ */
+function sanitize(type, value) {
+  const raw = value.replace(/[^A-Za-z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_+|_+$/g, '');
+  const fallback = raw.length > 0 ? raw : `${type}_item`;
+  if (/^[A-Za-z_]/.test(fallback)) return fallback;
+  return `${type}_${fallback}`;
+}
+
+/**
+ * Create a deterministic unique field name.
+ * @param {Set<string>} used - Used field names for the root type.
+ * @param {string} base - Base field candidate.
+ * @returns {string}
+ */
+function unique(used, base) {
+  let next = base;
+  let index = 2;
+
+  while (used.has(next)) {
+    next = `${base}_${index}`;
+    index += 1;
+  }
+
+  used.add(next);
+  return next;
+}
+
+/**
+ * Build catalog entries for a specific type.
+ * @param {Array<Record<string, unknown>>} list - Catalog items.
+ * @param {string} type - Desired type.
+ * @returns {Array<Record<string, unknown>>}
+ */
+function bytype(list, type) {
+  const out = [];
+  for (const item of list) {
+    if (item && item.type === type) out.push(item);
+  }
+  return out;
+}
+
+/**
+ * Sort entries in a stable deterministic way.
+ * @param {Array<Record<string, unknown>>} list - Input list.
+ * @returns {Array<Record<string, unknown>>}
+ */
+function sortstable(list) {
+  return list
+    .map(function wrap(item, index) {
+      return { item, index };
+    })
+    .sort(function compare(a, b) {
+      const left = typeof a.item.name === 'string' ? a.item.name : '';
+      const right = typeof b.item.name === 'string' ? b.item.name : '';
+      if (left < right) return -1;
+      if (left > right) return 1;
+      return a.index - b.index;
+    })
+    .map(function unwrap(entry) {
+      return entry.item;
+    });
+}
+
+/**
+ * Create a deterministic catalog map for adapters.
+ * @param {{ items?: Array<Record<string, unknown>> }} catalog - Extracted catalog.
+ * @returns {{ tools: Array<Record<string, unknown>>, prompts: Array<Record<string, unknown>>, resources: Array<Record<string, unknown>>, templates: Array<Record<string, unknown>>, entries: Array<{ type: string, root: 'query' | 'mutation', name: string, field: string, item: Record<string, unknown> }>, byType: (type: string) => Array<Record<string, unknown>>, find: (type: string, name: string) => Record<string, unknown> | undefined, findField: (type: string, name: string) => string | undefined }}
+ */
+export function createMap(catalog = {}) {
+  const items = Array.isArray(catalog.items) ? catalog.items : [];
+  const tools = sortstable(bytype(items, 'tool'));
+  const prompts = sortstable(bytype(items, 'prompt'));
+  const resources = sortstable(bytype(items, 'resource'));
+  const templates = sortstable(bytype(items, 'resource-template'));
+
+  const usedMutation = new Set(['callTool', 'getPrompt']);
+  const usedQuery = new Set(['catalog', 'readResource', 'readTemplate']);
+  const entries = [];
+  const lookup = new Map();
+  const fields = new Map();
+
+  /**
+   * Register entry metadata for deterministic lookup.
+   * @param {'query' | 'mutation'} root - GraphQL root type.
+   * @param {string} type - Catalog item type.
+   * @param {Record<string, unknown>} item - Catalog item.
+   * @returns {void}
+   */
+  function add(root, type, item) {
+    const name = typeof item.name === 'string' ? item.name : `${type}_item`;
+    const base = sanitize(type, name);
+    const field = root === 'mutation'
+      ? unique(usedMutation, base)
+      : unique(usedQuery, base);
+
+    entries.push({ type, root, name, field, item });
+    lookup.set(`${type}:${name}`, item);
+    fields.set(`${type}:${name}`, field);
+  }
+
+  for (const item of tools) add('mutation', 'tool', item);
+  for (const item of prompts) add('mutation', 'prompt', item);
+  for (const item of resources) add('query', 'resource', item);
+  for (const item of templates) add('query', 'resource-template', item);
+
+  /**
+   * Select items by a known catalog type.
+   * @param {string} type - Catalog type.
+   * @returns {Array<Record<string, unknown>>}
+   */
+  function selectByType(type) {
+    if (type === 'tool') return tools;
+    if (type === 'prompt') return prompts;
+    if (type === 'resource') return resources;
+    if (type === 'resource-template') return templates;
+    return [];
+  }
+
+  /**
+   * Find a catalog item by type and name.
+   * @param {string} type - Catalog type.
+   * @param {string} name - Item name.
+   * @returns {Record<string, unknown> | undefined}
+   */
+  function find(type, name) {
+    return lookup.get(`${type}:${name}`);
+  }
+
+  /**
+   * Find a generated GraphQL field by type and item name.
+   * @param {string} type - Catalog type.
+   * @param {string} name - Item name.
+   * @returns {string | undefined}
+   */
+  function findField(type, name) {
+    return fields.get(`${type}:${name}`);
+  }
+
+  return {
+    tools,
+    prompts,
+    resources,
+    templates,
+    entries,
+    byType: selectByType,
+    find,
+    findField
+  };
+}
+
+export { TYPES };

package/src/resilience/breaker.js

@@ -0,0 +1,97 @@
+import CircuitBreaker from 'opossum';
+
+/**
+ * Build MCP client request options from a breaker instance.
+ * @param {CircuitBreaker | null} breaker - Breaker instance or null.
+ * @returns {import('@modelcontextprotocol/sdk/shared/protocol.js').RequestOptions | undefined}
+ */
+function requestOptions(breaker) {
+  // Pass timeout through to the MCP client so underlying calls are canceled
+  // instead of lingering after the breaker timed out.
+  if (!breaker || !breaker.options || typeof breaker.options.timeout !== 'number') return undefined;
+  return { timeout: breaker.options.timeout };
+}
+
+/**
+ * Create a circuit breaker for an MCP session.
+ * @param {import('@mcp-layer/session').Session} session - MCP session.
+ * @param {{ timeout: number, errorThresholdPercentage: number, resetTimeout: number, volumeThreshold: number }} config - Breaker configuration.
+ * @returns {CircuitBreaker}
+ */
+export function createCircuitBreaker(session, config) {
+  const breaker = new CircuitBreaker(
+    async function call(task) {
+      const options = task.options;
+      if (task.method === 'tools/call') return session.client.callTool(task.params, undefined, options);
+      if (task.method === 'prompts/get') return session.client.getPrompt(task.params, options);
+      if (task.method === 'resources/read') return session.client.readResource(task.params, options);
+      return session.client.request({ method: task.method, params: task.params }, undefined, options);
+    },
+    {
+      timeout: config.timeout,
+      errorThresholdPercentage: config.errorThresholdPercentage,
+      resetTimeout: config.resetTimeout,
+      volumeThreshold: config.volumeThreshold,
+      name: `mcp-${session.name}`
+    }
+  );
+
+  breaker.on('open', function onOpen() {
+    if (session.log && typeof session.log.warn === 'function') {
+      session.log.warn({ session: session.name }, 'Circuit breaker OPENED - failing fast');
+    }
+  });
+
+  breaker.on('halfOpen', function onHalfOpen() {
+    if (session.log && typeof session.log.info === 'function') {
+      session.log.info({ session: session.name }, 'Circuit breaker HALF-OPEN - testing recovery');
+    }
+  });
+
+  breaker.on('close', function onClose() {
+    if (session.log && typeof session.log.info === 'function') {
+      session.log.info({ session: session.name }, 'Circuit breaker CLOSED - normal operation');
+    }
+  });
+
+  breaker.on('timeout', function onTimeout() {
+    if (session.log && typeof session.log.warn === 'function') {
+      session.log.warn({ session: session.name }, 'Circuit breaker request timed out');
+    }
+  });
+
+  breaker.on('reject', function onReject() {
+    if (session.log && typeof session.log.debug === 'function') {
+      session.log.debug({ session: session.name }, 'Circuit breaker rejected request (open)');
+    }
+  });
+
+  return breaker;
+}
+
+/**
+ * Execute an MCP call through a circuit breaker if enabled.
+ * @param {CircuitBreaker | null} breaker - Breaker instance or null if disabled.
+ * @param {import('@mcp-layer/session').Session} session - MCP session.
+ * @param {string} method - MCP method name.
+ * @param {Record<string, unknown>} params - MCP parameters.
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function executeWithBreaker(breaker, session, method, params) {
+  const options = requestOptions(breaker);
+  if (!breaker) {
+    if (method === 'tools/call') return session.client.callTool(params);
+    if (method === 'prompts/get') return session.client.getPrompt(params);
+    if (method === 'resources/read') return session.client.readResource(params);
+    return session.client.request({ method, params });
+  }
+
+  if (breaker.opened) {
+    const error = new Error('Circuit breaker is open');
+    error.code = 'CIRCUIT_OPEN';
+    error.sessionName = breaker.name.replace('mcp-', '');
+    throw error;
+  }
+
+  return breaker.fire({ method, params, options });
+}

package/src/runtime.js

@@ -0,0 +1,194 @@
+import { extract } from '@mcp-layer/schema';
+import { createValidator } from './validation/validator.js';
+import { createCircuitBreaker, executeWithBreaker } from './resilience/breaker.js';
+import { deriveApiVersion, resolvePrefix } from './version.js';
+import { createTelemetry } from './telemetry/index.js';
+import { validateRuntimeOptions } from './config/validate.js';
+
+/**
+ * Normalize a session input into an array.
+ * @param {import('@mcp-layer/session').Session | Array<import('@mcp-layer/session').Session>} session - Session or session list.
+ * @returns {Array<import('@mcp-layer/session').Session>}
+ */
+function list(session) {
+  return Array.isArray(session) ? session : [session];
+}
+
+/**
+ * Register tool and prompt validators from a catalog.
+ * @param {import('./validation/validator.js').SchemaValidator} validator - Schema validator.
+ * @param {{ items?: Array<Record<string, unknown>> }} catalog - Extracted catalog.
+ * @returns {void}
+ */
+function registerCatalogValidators(validator, catalog) {
+  const items = Array.isArray(catalog.items) ? catalog.items : [];
+
+  for (const item of items) {
+    if (item.type === 'tool' && item.name && item.detail?.input?.json) {
+      validator.registerToolSchema(String(item.name), item.detail.input.json);
+    }
+
+    if (item.type === 'prompt' && item.name && item.detail?.input?.json) {
+      validator.registerPromptSchema(String(item.name), item.detail.input.json);
+    }
+  }
+}
+
+/**
+ * Ensure a circuit breaker exists for a session.
+ * @param {Map<string, import('opossum')>} breakers - Runtime breaker map.
+ * @param {import('@mcp-layer/session').Session} session - Target session.
+ * @param {{ enabled: boolean, timeout: number, errorThresholdPercentage: number, resetTimeout: number, volumeThreshold: number }} config - Resilience config.
+ * @param {ReturnType<import('./telemetry/index.js').createTelemetry> | null} telemetry - Telemetry helper.
+ * @returns {import('opossum') | null}
+ */
+function ensureBreaker(breakers, session, config, telemetry) {
+  if (!config.enabled) return null;
+
+  const existing = breakers.get(session.name);
+  if (existing) return existing;
+
+  const breaker = createCircuitBreaker(session, config);
+  breakers.set(session.name, breaker);
+
+  if (telemetry) {
+    telemetry.setCircuitState(session.name, 'closed');
+    breaker.on('open', function onOpen() {
+      telemetry.setCircuitState(session.name, 'open');
+    });
+    breaker.on('halfOpen', function onHalfOpen() {
+      telemetry.setCircuitState(session.name, 'half_open');
+    });
+    breaker.on('close', function onClose() {
+      telemetry.setCircuitState(session.name, 'closed');
+    });
+  }
+
+  return breaker;
+}
+
+/**
+ * Resolve request-scoped session and breaker.
+ * @param {import('@mcp-layer/session').Session} bootstrap - Bootstrap session.
+ * @param {{ manager?: { get: (request: import('fastify').FastifyRequest) => Promise<import('@mcp-layer/session').Session> }, resilience: { enabled: boolean, timeout: number, errorThresholdPercentage: number, resetTimeout: number, volumeThreshold: number } }} config - Runtime config.
+ * @param {Map<string, import('opossum')>} breakers - Breaker storage.
+ * @param {ReturnType<import('./telemetry/index.js').createTelemetry> | null} telemetry - Telemetry helper.
+ * @param {import('fastify').FastifyRequest} request - Incoming request.
+ * @returns {Promise<{ session: import('@mcp-layer/session').Session, breaker: import('opossum') | null }>}
+ */
+async function resolveSession(bootstrap, config, breakers, telemetry, request) {
+  const target = config.manager ? await config.manager.get(request) : bootstrap;
+  const breaker = ensureBreaker(breakers, target, config.resilience, telemetry);
+  return { session: target, breaker };
+}
+
+/**
+ * Create shared runtime contexts for MCP adapters.
+ * @param {Record<string, unknown>} opts - Runtime options.
+ * @param {{ name?: string, serviceName?: string }} [meta] - Runtime metadata.
+ * @returns {Promise<{ config: ReturnType<typeof validateRuntimeOptions>, contexts: Array<{ session: import('@mcp-layer/session').Session, catalog: { server?: { info?: Record<string, unknown> }, items?: Array<Record<string, unknown>> }, info: Record<string, unknown> | undefined, version: string, prefix: string, validator: import('./validation/validator.js').SchemaValidator, telemetry: ReturnType<typeof createTelemetry> | null, resolve: (request: import('fastify').FastifyRequest) => Promise<{ session: import('@mcp-layer/session').Session, breaker: import('opossum') | null }>, execute: (request: import('fastify').FastifyRequest, method: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>, normalize: (error: Error & { code?: string | number }, instance: string, requestId?: string) => unknown }>, breakers: Map<string, import('opossum')>, normalize: (error: Error & { code?: string | number }, instance: string, requestId?: string) => unknown, close: () => Promise<void> }>}
+ */
+export async function createRuntime(opts, meta = {}) {
+  const config = validateRuntimeOptions(opts, meta);
+  const sessions = config.manager ? [config.session] : list(config.session);
+  const breakers = new Map();
+  const contexts = [];
+
+  /**
+   * Normalize adapter errors using configured mapper.
+   * @param {Error & { code?: string | number }} error - Runtime error.
+   * @param {string} instance - Request instance identifier.
+   * @param {string} [requestId] - Request id.
+   * @returns {unknown}
+   */
+  function normalize(error, instance, requestId) {
+    if (config.normalizeError) {
+      return config.normalizeError(error, instance, requestId, config.errors);
+    }
+
+    return {
+      error,
+      instance,
+      requestId,
+      options: config.errors
+    };
+  }
+
+  for (const session of sessions) {
+    const catalog = await extract(session);
+    const info = catalog.server?.info;
+    const version = deriveApiVersion(info);
+    const prefix = resolvePrefix(config.prefix, version, info, session.name);
+    const validator = createValidator(config.validation, session);
+    const telemetry = createTelemetry(config.telemetry);
+
+    registerCatalogValidators(validator, catalog);
+
+    /**
+     * Resolve session context for a request.
+     * @param {import('fastify').FastifyRequest} request - Incoming request.
+     * @returns {Promise<{ session: import('@mcp-layer/session').Session, breaker: import('opossum') | null }>}
+     */
+    async function resolve(request) {
+      return resolveSession(session, config, breakers, telemetry, request);
+    }
+
+    /**
+     * Execute an MCP method with request-scoped session resolution.
+     * @param {import('fastify').FastifyRequest} request - Incoming request.
+     * @param {string} method - MCP method.
+     * @param {Record<string, unknown>} params - MCP params.
+     * @returns {Promise<Record<string, unknown>>}
+     */
+    async function execute(request, method, params) {
+      const resolved = await resolve(request);
+      return executeWithBreaker(resolved.breaker, resolved.session, method, params);
+    }
+
+    /**
+     * Normalize a runtime error.
+     * @param {Error & { code?: string | number }} error - Runtime error.
+     * @param {string} instance - Request instance identifier.
+     * @param {string} [requestId] - Request id.
+     * @returns {unknown}
+     */
+    function contextNormalize(error, instance, requestId) {
+      return normalize(error, instance, requestId);
+    }
+
+    contexts.push({
+      session,
+      catalog,
+      info,
+      version,
+      prefix,
+      validator,
+      telemetry,
+      resolve,
+      execute,
+      normalize: contextNormalize
+    });
+  }
+
+  /**
+   * Close runtime resources.
+   * @returns {Promise<void>}
+   */
+  async function close() {
+    for (const breaker of breakers.values()) {
+      breaker.shutdown();
+    }
+
+    if (config.manager && typeof config.manager.close === 'function') {
+      await config.manager.close();
+    }
+  }
+
+  return {
+    config,
+    contexts,
+    breakers,
+    normalize,
+    close
+  };
+}