mcp-tool-bridge 1.1.0

package/dist/index.cjs

@@ -0,0 +1,1328 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkXMYSMKGRcjs = require('./chunk-XMYSMKGR.cjs');
+
+// src/access.ts
+function canAccess(tool, principal) {
+  return tool.roles.some((role) => principal.roles.includes(role));
+}
+function visibleTools(tools, principal) {
+  const visible = [];
+  for (const tool of tools) if (canAccess(tool, principal)) visible.push(tool);
+  return visible;
+}
+function parsePrincipal(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("a principal must be an object with an id and roles");
+  }
+  const id = Reflect.get(value, "id");
+  if (typeof id !== "string" || id.trim() === "") {
+    throw new TypeError("a principal needs a non-empty string id");
+  }
+  const roles = Reflect.get(value, "roles");
+  if (!Array.isArray(roles)) throw new TypeError(`principal "${id}": roles must be an array`);
+  const copy = [];
+  for (const role of roles) {
+    if (typeof role !== "string" || role === "") {
+      throw new TypeError(`principal "${id}": every role must be a non-empty string`);
+    }
+    copy.push(role);
+  }
+  return Object.freeze({ id, roles: Object.freeze(copy) });
+}
+
+// src/adapters/adapt.ts
+function adapt(fn, spec) {
+  return async (args, call) => spec.output(await fn(spec.input(args, call)));
+}
+
+// src/schema/jsonSchema.ts
+var _2020js = require('ajv/dist/2020.js');
+var _ajvformats = require('ajv-formats'); var _ajvformats2 = _interopRequireDefault(_ajvformats);
+function jsonSchema(schema) {
+  const compiled = compileJsonSchema(schema);
+  const parse = (input) => {
+    const result = compiled.parse(input);
+    if (!result.ok) return result;
+    const typed = result.value;
+    return { ok: true, value: typed };
+  };
+  return Object.freeze({ jsonSchema: compiled.jsonSchema, parse });
+}
+function compileJsonSchema(schema, tool) {
+  const root = _chunkXMYSMKGRcjs.freezeRootSchema.call(void 0, schema, tool);
+  const ajv = new (0, _2020js.Ajv2020)({
+    allErrors: true,
+    strict: true,
+    coerceTypes: false,
+    useDefaults: false,
+    removeAdditional: false
+  });
+  _ajvformats2.default.call(void 0, ajv);
+  let validate;
+  try {
+    validate = ajv.compile(root);
+  } catch (error) {
+    const prefix = tool === void 0 ? "" : `tool "${tool}": `;
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "invalid_schema",
+      `${prefix}invalid JSON Schema: ${messageOf(error)}`,
+      {
+        tool,
+        cause: error
+      }
+    );
+  }
+  const parse = (input) => {
+    const copy = _chunkXMYSMKGRcjs.cloneJson.call(void 0, input);
+    if (!copy.ok) return { ok: false, issues: [_chunkXMYSMKGRcjs.NOT_JSON_ISSUE] };
+    const value = copy.value;
+    if (!validate(value)) return { ok: false, issues: toIssues(validate.errors) };
+    if (!_chunkXMYSMKGRcjs.isJsonObject.call(void 0, value))
+      return { ok: false, issues: [{ path: "", message: "must be object" }] };
+    return { ok: true, value };
+  };
+  return Object.freeze({ jsonSchema: root, parse });
+}
+function toIssues(errors) {
+  if (!errors || errors.length === 0) return [{ path: "", message: "is invalid" }];
+  return errors.slice(0, _chunkXMYSMKGRcjs.MAX_ISSUES).map((error) => {
+    const params = error.params;
+    let path = error.instancePath;
+    if (error.keyword === "required" && typeof params.missingProperty === "string") {
+      path += `/${_chunkXMYSMKGRcjs.pointerSegment.call(void 0, params.missingProperty)}`;
+    }
+    if (error.keyword === "additionalProperties" && typeof params.additionalProperty === "string") {
+      path += `/${_chunkXMYSMKGRcjs.pointerSegment.call(void 0, params.additionalProperty)}`;
+    }
+    return { path, message: _nullishCoalesce(error.message, () => ( "is invalid")) };
+  });
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/types.ts
+var SENSITIVITY_LEVELS = ["none", "low", "medium", "high", "critical"];
+function isSensitivity(value) {
+  return typeof value === "string" && SENSITIVITY_LEVELS.includes(value);
+}
+function sensitivityRank(level) {
+  return SENSITIVITY_LEVELS.indexOf(level);
+}
+
+// src/tool.ts
+var internals = /* @__PURE__ */ new WeakMap();
+var TOOL_NAME = /^[A-Za-z0-9_.-]{1,128}$/;
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+function defineTool(definition) {
+  const descriptor = checkDefinition(definition);
+  const { args, handler, summarize } = definition;
+  const { name, title } = descriptor;
+  const tool = Object.freeze({
+    ...descriptor,
+    inputSchema: _chunkXMYSMKGRcjs.freezeRootSchema.call(void 0, args.jsonSchema, name)
+  });
+  const prepare = (input) => {
+    const parsed = args.parse(input);
+    if (!parsed.ok) return { ok: false, issues: parsed.issues };
+    const value = parsed.value;
+    return {
+      ok: true,
+      summary: summarize ? summarize(value) : _nullishCoalesce(title, () => ( name)),
+      run: (call) => handler(value, call)
+    };
+  };
+  internals.set(tool, { prepare });
+  return tool;
+}
+function isTool(value) {
+  return typeof value === "object" && value !== null && internals.has(value);
+}
+function prepareCall(tool, input) {
+  const found = internals.get(tool);
+  if (!found) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)("not_a_tool", "this object was not created by defineTool()");
+  }
+  return found.prepare(input);
+}
+function exposeTool(tool) {
+  const readOnly = tool.sensitivity === "none";
+  const destructive = !readOnly && !tool.reversible;
+  return tool.title === void 0 ? {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: { readOnlyHint: readOnly, destructiveHint: destructive }
+  } : {
+    name: tool.name,
+    title: tool.title,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: { title: tool.title, readOnlyHint: readOnly, destructiveHint: destructive }
+  };
+}
+function checkDefinition(definition) {
+  if (typeof definition !== "object" || definition === null) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)("invalid_definition", "a tool definition must be an object");
+  }
+  const name = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "name");
+  if (typeof name !== "string" || !TOOL_NAME.test(name)) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "invalid_name",
+      `invalid tool name ${JSON.stringify(name)}: use 1 to 128 characters among A-Z a-z 0-9 _ - .`
+    );
+  }
+  const fail = (code, message) => new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(code, `tool "${name}": ${message}`, { tool: name });
+  const title = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "title");
+  if (!(title === void 0 || isNonEmptyString(title))) {
+    throw fail("invalid_title", "`title` must be a non-empty string when present");
+  }
+  const description = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "description");
+  if (!isNonEmptyString(description)) {
+    throw fail("invalid_description", "`description` is required: it is all the model reads");
+  }
+  if (!isArgsSchema(_chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "args"))) {
+    throw fail(
+      "invalid_schema",
+      "`args` must come from jsonSchema(), zodSchema() or match ArgsSchema"
+    );
+  }
+  const sensitivity = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "sensitivity");
+  if (!isSensitivity(sensitivity)) {
+    throw fail("invalid_sensitivity", "expected none, low, medium, high or critical");
+  }
+  const reversible = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "reversible");
+  if (typeof reversible !== "boolean") {
+    throw fail("invalid_reversible", "`reversible` must be declared, true or false");
+  }
+  const roles = checkRoles(_chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "roles"), fail);
+  const confirm = _nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "confirm"), () => ( "auto"));
+  if (confirm !== "auto" && confirm !== "always") {
+    throw fail("invalid_confirm", '`confirm` must be "auto" or "always"');
+  }
+  const summarize = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "summarize");
+  if (summarize !== void 0 && typeof summarize !== "function") {
+    throw fail("invalid_summarize", "`summarize` must be a function");
+  }
+  const audit = checkAudit(_chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "audit"), fail);
+  const timeoutMs = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "timeoutMs");
+  if (!(timeoutMs === void 0 || isTimeout(timeoutMs))) {
+    throw fail("invalid_timeout", "`timeoutMs` must be a positive integer of milliseconds");
+  }
+  if (typeof _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "handler") !== "function") {
+    throw fail("invalid_handler", "`handler` must be a function");
+  }
+  return { name, title, description, sensitivity, reversible, roles, confirm, audit, timeoutMs };
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isTimeout(value) {
+  return Number.isInteger(value) && typeof value === "number" && value > 0 && value <= MAX_TIMEOUT_MS;
+}
+function isArgsSchema(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "parse" in value && typeof value.parse === "function" && "jsonSchema" in value;
+}
+function checkRoles(value, fail) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw fail("invalid_roles", "`roles` must list at least one role");
+  }
+  const roles = /* @__PURE__ */ new Set();
+  for (const role of value) {
+    if (typeof role !== "string" || role === "" || role.trim() !== role) {
+      throw fail("invalid_roles", `invalid role ${JSON.stringify(role)}`);
+    }
+    roles.add(role);
+  }
+  return Object.freeze([...roles]);
+}
+function checkAudit(value, fail) {
+  if (value === void 0)
+    return Object.freeze({ args: Object.freeze([]), result: Object.freeze([]) });
+  if (typeof value !== "object" || value === null) {
+    throw fail("invalid_audit", '`audit` must be an object such as { args: ["/messageId"] }');
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "args" && key !== "result") {
+      throw fail("invalid_audit", `unknown audit field ${JSON.stringify(key)}: use args or result`);
+    }
+  }
+  return Object.freeze({
+    args: checkPointers(_chunkXMYSMKGRcjs.readProperty.call(void 0, value, "args"), "audit.args", fail),
+    result: checkPointers(_chunkXMYSMKGRcjs.readProperty.call(void 0, value, "result"), "audit.result", fail)
+  });
+}
+function checkPointers(value, field, fail) {
+  if (value === void 0) return Object.freeze([]);
+  if (!Array.isArray(value))
+    throw fail("invalid_audit", `\`${field}\` must be an array of JSON Pointers`);
+  const pointers = [];
+  for (const pointer of value) {
+    if (typeof pointer !== "string" || !pointer.startsWith("/") || pointer === "/") {
+      throw fail(
+        "invalid_audit",
+        `${JSON.stringify(pointer)} in ${field} is not a JSON Pointer such as "/messageId"`
+      );
+    }
+    pointers.push(pointer);
+  }
+  return Object.freeze(pointers);
+}
+
+// src/adapters/definitions.ts
+var NO_PARAMETERS = Object.freeze({
+  type: "object",
+  properties: Object.freeze({}),
+  additionalProperties: false
+});
+function importDefinitions(definitions, dispatch, governance) {
+  const parsed = definitions.map(normalize);
+  const seen = /* @__PURE__ */ new Set();
+  for (const { name } of parsed) {
+    if (seen.has(name)) {
+      throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)("duplicate_name", `two definitions are named "${name}"`, {
+        tool: name
+      });
+    }
+    seen.add(name);
+  }
+  const missing = parsed.map(({ name }) => name).filter((name) => !Object.hasOwn(governance, name));
+  if (missing.length > 0) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "missing_governance",
+      `no governance declared for: ${missing.join(", ")}. Declare sensitivity, reversible and roles for each.`
+    );
+  }
+  const unknown = Object.keys(governance).filter((name) => !seen.has(name));
+  if (unknown.length > 0) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "unknown_governance",
+      `governance declared for tools that have no definition: ${unknown.join(", ")}`
+    );
+  }
+  return parsed.map(({ name, description, schema }) => {
+    const rules = governance[name];
+    if (rules === void 0) throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)("missing_governance", name);
+    return defineTool({
+      ...rules,
+      name,
+      description,
+      args: compileJsonSchema(_nullishCoalesce(schema, () => ( NO_PARAMETERS)), name),
+      handler: (args, call) => dispatch(name, args, call)
+    });
+  });
+}
+function normalize(definition, index) {
+  if (typeof definition !== "object" || definition === null) {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "invalid_definition",
+      `definition #${String(index)} is not an object`
+    );
+  }
+  const nested = _chunkXMYSMKGRcjs.readProperty.call(void 0, definition, "function");
+  const source = typeof nested === "object" && nested !== null ? nested : definition;
+  const name = _chunkXMYSMKGRcjs.readProperty.call(void 0, source, "name");
+  if (typeof name !== "string") {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)("invalid_name", `definition #${String(index)} has no name`);
+  }
+  const description = _chunkXMYSMKGRcjs.readProperty.call(void 0, source, "description");
+  if (typeof description !== "string" || description.trim() === "") {
+    throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+      "invalid_description",
+      `tool "${name}": a description is required, it is all the model reads`,
+      { tool: name }
+    );
+  }
+  const schema = _nullishCoalesce(_nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, source, "input_schema"), () => ( _chunkXMYSMKGRcjs.readProperty.call(void 0, source, "inputSchema"))), () => ( _chunkXMYSMKGRcjs.readProperty.call(void 0, source, "parameters")));
+  return { name, description, schema };
+}
+
+// src/adapters/envelope.ts
+function envelope(spec) {
+  return (result) => {
+    if (!spec.ok(result)) throw new (0, _chunkXMYSMKGRcjs.ToolError)(spec.message(result));
+    return spec.value(result);
+  };
+}
+
+// src/audit/redact.ts
+var REDACTED = "[REDACTED]";
+var SECRET_KEY_PARTS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "apikey",
+  "authorization",
+  "cookie",
+  "privatekey"
+];
+var MAX_KEPT_STRING = 500;
+var MAX_KEPT_ITEMS = 100;
+function isSecretKey(key) {
+  const normalized = key.toLowerCase().replaceAll(/[-_]/g, "");
+  return SECRET_KEY_PARTS.some((part) => normalized.includes(part));
+}
+function keepDeclared(value, pointers) {
+  if (pointers.length === 0) return void 0;
+  const kept = {};
+  for (const pointer of pointers) {
+    const segments = parsePointer(pointer);
+    const last = segments.at(-1);
+    const secret = last !== void 0 && last !== "*" && isSecretKey(last);
+    const matches = resolve(value, segments).slice(0, MAX_KEPT_ITEMS);
+    if (matches.length === 0) continue;
+    const copies = matches.map((match) => secret ? REDACTED : bound(match));
+    kept[pointer] = segments.includes("*") ? copies : _nullishCoalesce(copies[0], () => ( null));
+  }
+  return kept;
+}
+function auditResult(result, pointers) {
+  const isError = result.isError === true;
+  const kept = result.structuredContent === void 0 ? void 0 : keepDeclared(result.structuredContent, pointers);
+  return kept === void 0 ? { isError } : { isError, kept };
+}
+function resolve(value, segments) {
+  const [head, ...rest] = segments;
+  if (head === void 0) return [value];
+  if (head === "*") {
+    const children = _chunkXMYSMKGRcjs.isJsonArray.call(void 0, value) ? [...value] : _chunkXMYSMKGRcjs.isJsonObject.call(void 0, value) ? Object.values(value) : [];
+    return children.flatMap((child) => resolve(child, rest));
+  }
+  if (_chunkXMYSMKGRcjs.isJsonArray.call(void 0, value)) {
+    if (!/^(0|[1-9][0-9]*)$/.test(head)) return [];
+    const item2 = value[Number(head)];
+    return item2 === void 0 ? [] : resolve(item2, rest);
+  }
+  if (!_chunkXMYSMKGRcjs.isJsonObject.call(void 0, value) || !Object.hasOwn(value, head)) return [];
+  const item = value[head];
+  return item === void 0 ? [] : resolve(item, rest);
+}
+function bound(value) {
+  if (typeof value === "string") {
+    return value.length > MAX_KEPT_STRING ? `${value.slice(0, MAX_KEPT_STRING)}\u2026` : value;
+  }
+  if (_chunkXMYSMKGRcjs.isJsonArray.call(void 0, value)) return value.slice(0, MAX_KEPT_ITEMS).map(bound);
+  if (!_chunkXMYSMKGRcjs.isJsonObject.call(void 0, value)) return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value))
+    out[key] = isSecretKey(key) ? REDACTED : bound(item);
+  return out;
+}
+function parsePointer(pointer) {
+  return pointer.split("/").slice(1).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+
+// src/audit/sinks.ts
+function stderrJsonSink() {
+  return {
+    write(event) {
+      process.stderr.write(`${JSON.stringify(event)}
+`);
+    }
+  };
+}
+function memorySink() {
+  const events = [];
+  return {
+    events,
+    write(event) {
+      events.push(event);
+    },
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+
+// src/bridge.ts
+var _crypto = require('crypto');
+
+// src/confirmation/policy.ts
+var DEFAULT_POLICY = Object.freeze({
+  threshold: "high",
+  irreversibleLowersThreshold: true
+});
+function isConfirmationThreshold(value) {
+  return isSensitivity(value) && value !== "none";
+}
+function requiresConfirmation(tool, policy = DEFAULT_POLICY) {
+  if (tool.confirm === "always") return true;
+  if (tool.sensitivity === "none") return false;
+  const lowered = policy.irreversibleLowersThreshold && !tool.reversible ? 1 : 0;
+  return sensitivityRank(tool.sensitivity) >= sensitivityRank(policy.threshold) - lowered;
+}
+
+// src/confirmation/store.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var MemoryConfirmationStore = class {
+  #records = /* @__PURE__ */ new Map();
+  #consumed = /* @__PURE__ */ new Map();
+  #maxEntries;
+  #maxConsumed;
+  #retentionMs;
+  #now;
+  constructor(options = {}) {
+    this.#maxEntries = positiveInteger(_nullishCoalesce(options.maxEntries, () => ( 1e4)), "maxEntries");
+    this.#maxConsumed = positiveInteger(_nullishCoalesce(options.maxConsumed, () => ( 1e4)), "maxConsumed");
+    this.#retentionMs = positiveInteger(
+      _nullishCoalesce(options.consumedRetentionMs, () => ( DAY_MS)),
+      "consumedRetentionMs"
+    );
+    this.#now = _nullishCoalesce(options.now, () => ( Date.now));
+  }
+  /** Pending confirmations. */
+  get size() {
+    return this.#records.size;
+  }
+  /** Remembered consumed or expired tokens. */
+  get consumedSize() {
+    return this.#consumed.size;
+  }
+  put(record) {
+    const now = this.#now();
+    this.#forgetExpiredTombstones(now);
+    if (this.#records.size >= this.#maxEntries) this.#evictRecords(now);
+    this.#records.set(record.tokenHash, record);
+    return Promise.resolve();
+  }
+  take(tokenHash, now) {
+    const record = this.#records.get(tokenHash);
+    if (record) {
+      this.#records.delete(tokenHash);
+      this.#remember(tokenHash, "consumed", record.expiresAt, now);
+      return Promise.resolve(
+        record.expiresAt <= now ? { status: "expired", record } : { status: "taken", record }
+      );
+    }
+    const tombstone = this.#consumed.get(tokenHash);
+    if (!tombstone || tombstone.until <= now) return Promise.resolve({ status: "unknown" });
+    if (tombstone.outcome === "expired") {
+      this.#consumed.set(tokenHash, { ...tombstone, outcome: "consumed" });
+      return Promise.resolve({ status: "expired" });
+    }
+    return Promise.resolve({ status: "consumed" });
+  }
+  #remember(tokenHash, outcome, expiresAt, now) {
+    this.#forgetExpiredTombstones(now);
+    if (this.#consumed.size >= this.#maxConsumed) {
+      const oldest = this.#consumed.keys().next();
+      if (!oldest.done) this.#consumed.delete(oldest.value);
+    }
+    this.#consumed.set(tokenHash, { outcome, until: Math.max(expiresAt, now) + this.#retentionMs });
+  }
+  #forgetExpiredTombstones(now) {
+    for (const [hash, tombstone] of this.#consumed) {
+      if (tombstone.until <= now) this.#consumed.delete(hash);
+    }
+  }
+  #evictRecords(now) {
+    for (const [hash, record] of this.#records) {
+      if (record.expiresAt <= now) {
+        this.#records.delete(hash);
+        this.#remember(hash, "expired", record.expiresAt, now);
+      }
+    }
+    for (const hash of this.#records.keys()) {
+      if (this.#records.size < this.#maxEntries) break;
+      this.#records.delete(hash);
+    }
+  }
+};
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1)
+    throw new TypeError(`${name} must be a positive integer`);
+  return value;
+}
+
+// src/confirmation/token.ts
+
+var TOKEN_PREFIX = "mtb_";
+function newToken() {
+  return TOKEN_PREFIX + _crypto.randomBytes.call(void 0, 32).toString("base64url");
+}
+function hashToken(token) {
+  return _crypto.createHash.call(void 0, "sha256").update(token, "utf8").digest("hex");
+}
+function digestArguments(args) {
+  return _crypto.createHash.call(void 0, "sha256").update(canonicalJson(args), "utf8").digest("hex");
+}
+function canonicalJson(value) {
+  if (_chunkXMYSMKGRcjs.isJsonArray.call(void 0, value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  if (_chunkXMYSMKGRcjs.isJsonObject.call(void 0, value)) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(_nullishCoalesce(value[key], () => ( null)))}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+// src/registry.ts
+var ToolRegistry = class {
+  #tools = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Set();
+  /**
+   * Adds tools, all or none: if one of them is invalid or its name is taken
+   * (by an existing tool or by another tool in the same call), the registry
+   * is left unchanged.
+   */
+  register(...tools) {
+    const incoming = /* @__PURE__ */ new Set();
+    for (const tool of tools) {
+      if (!isTool(tool)) {
+        throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+          "not_a_tool",
+          "only tools created by defineTool() can be registered"
+        );
+      }
+      if (this.#tools.has(tool.name) || incoming.has(tool.name)) {
+        throw new (0, _chunkXMYSMKGRcjs.ToolDefinitionError)(
+          "duplicate_name",
+          `a tool named "${tool.name}" already exists`,
+          {
+            tool: tool.name
+          }
+        );
+      }
+      incoming.add(tool.name);
+    }
+    if (tools.length === 0) return this;
+    for (const tool of tools) this.#tools.set(tool.name, tool);
+    this.#notify();
+    return this;
+  }
+  /** Removes a tool. Returns false if there was none by that name. */
+  unregister(name) {
+    const removed = this.#tools.delete(name);
+    if (removed) this.#notify();
+    return removed;
+  }
+  get(name) {
+    return this.#tools.get(name);
+  }
+  has(name) {
+    return this.#tools.has(name);
+  }
+  /** Every tool, in registration order, regardless of who is asking. */
+  list() {
+    return Object.freeze([...this.#tools.values()]);
+  }
+  get size() {
+    return this.#tools.size;
+  }
+  /**
+   * Called after every change. The MCP server uses it to send
+   * `notifications/tools/list_changed`. Returns an unsubscribe function.
+   */
+  onChange(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  #notify() {
+    for (const listener of [...this.#listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        process.emitWarning(
+          `mcp-tool-bridge: a registry onChange listener threw: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+};
+
+// src/result.ts
+function text(value) {
+  return Object.freeze({ content: Object.freeze([Object.freeze({ type: "text", text: value })]) });
+}
+function json(value) {
+  const copy = _chunkXMYSMKGRcjs.cloneJson.call(void 0, value);
+  if (!copy.ok) throw new TypeError("json(): value is not plain JSON data");
+  const frozen = _chunkXMYSMKGRcjs.deepFreeze.call(void 0, copy.value);
+  const content = Object.freeze([Object.freeze({ type: "text", text: JSON.stringify(frozen) })]);
+  return _chunkXMYSMKGRcjs.isJsonObject.call(void 0, frozen) ? Object.freeze({ content, structuredContent: frozen }) : Object.freeze({ content });
+}
+function normalizeOutput(output) {
+  if (typeof output === "string") return text(output);
+  const copy = _chunkXMYSMKGRcjs.cloneJson.call(void 0, output);
+  if (!copy.ok || !_chunkXMYSMKGRcjs.isJsonObject.call(void 0, copy.value)) return void 0;
+  const { content, structuredContent, isError } = copy.value;
+  if (!Array.isArray(content)) return void 0;
+  const blocks = [];
+  for (const item of content) {
+    const block = toBlock(item);
+    if (!block) return void 0;
+    blocks.push(block);
+  }
+  if (structuredContent !== void 0 && !_chunkXMYSMKGRcjs.isJsonObject.call(void 0, structuredContent)) return void 0;
+  if (isError !== void 0 && typeof isError !== "boolean") return void 0;
+  return Object.freeze({
+    content: Object.freeze(blocks),
+    ...structuredContent === void 0 ? {} : { structuredContent: _chunkXMYSMKGRcjs.deepFreeze.call(void 0, structuredContent) },
+    ...isError === void 0 ? {} : { isError }
+  });
+}
+function toBlock(item) {
+  if (!_chunkXMYSMKGRcjs.isJsonObject.call(void 0, item)) return void 0;
+  const { type, text: value, data, mimeType } = item;
+  if (type === "text")
+    return typeof value === "string" ? Object.freeze({ type, text: value }) : void 0;
+  if ((type === "image" || type === "audio") && typeof data === "string" && typeof mimeType === "string") {
+    return Object.freeze({ type, data, mimeType });
+  }
+  return void 0;
+}
+
+// src/bridge.ts
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var MESSAGES = {
+  exception: "The tool failed unexpectedly. The failure was recorded.",
+  aborted: "The call was cancelled.",
+  auditUnavailable: "The call was not executed: the audit log is unavailable.",
+  timeout: (ms) => `The tool did not answer within ${String(ms)} ms.`
+};
+function createBridge(options) {
+  return new ToolBridge(checkOptions(options));
+}
+function scope(callId, transport, principal, name, tool, args) {
+  const keepArgs = _nullishCoalesce(_optionalChain([tool, 'optionalAccess', _ => _.audit, 'access', _2 => _2.args]), () => ( []));
+  return {
+    callId,
+    transport,
+    principal,
+    tool: name,
+    argsDigest: args === void 0 ? void 0 : digestArguments(args),
+    keptArgs: args === void 0 || !_chunkXMYSMKGRcjs.isJsonObject.call(void 0, args) ? void 0 : keepDeclared(args, keepArgs),
+    keepResult: _nullishCoalesce(_optionalChain([tool, 'optionalAccess', _3 => _3.audit, 'access', _4 => _4.result]), () => ( []))
+  };
+}
+var MAX_AUDITED_ERROR = 500;
+var ToolBridge = class {
+  
+  #settings;
+  constructor(settings) {
+    this.registry = settings.registry;
+    this.#settings = settings;
+  }
+  listTools(principal) {
+    const caller = parsePrincipal(principal);
+    return Object.freeze(visibleTools(this.registry.list(), caller).map(exposeTool));
+  }
+  async callTool(principal, request, options = {}) {
+    const caller = parsePrincipal(principal);
+    const copy = _chunkXMYSMKGRcjs.cloneJson.call(void 0, _nullishCoalesce(request.arguments, () => ( {})));
+    const args = copy.ok ? copy.value : void 0;
+    if (request.confirmationToken !== void 0) {
+      return this.#redeem(caller, request.confirmationToken, options, { name: request.name, args });
+    }
+    const callId = _crypto.randomUUID.call(void 0, );
+    const transport = _nullishCoalesce(options.transport, () => ( "direct"));
+    const tool = this.registry.get(request.name);
+    if (!tool) {
+      return this.#reject(
+        scope(callId, transport, caller, request.name, void 0, args),
+        "unknown_tool"
+      );
+    }
+    const inScope = scope(callId, transport, caller, tool.name, tool, args);
+    if (!canAccess(tool, caller)) return this.#reject(inScope, "forbidden");
+    if (args === void 0) return this.#rejectArguments(inScope, [_chunkXMYSMKGRcjs.NOT_JSON_ISSUE]);
+    let prepared;
+    try {
+      prepared = prepareCall(tool, args);
+    } catch (error) {
+      return this.#fail(inScope, false, 0, "exception", error);
+    }
+    if (!prepared.ok) return this.#rejectArguments(inScope, prepared.issues);
+    if (requiresConfirmation(tool, this.#settings.policy)) {
+      return this.#issue(inScope, tool, args, prepared.summary);
+    }
+    return this.#execute(inScope, tool, prepared, false, options.signal);
+  }
+  executeConfirmed(principal, token, options = {}) {
+    return this.#redeem(parsePrincipal(principal), token, options, void 0);
+  }
+  async revokeConfirmation(principal, token, options = {}) {
+    const caller = parsePrincipal(principal);
+    const transport = _nullishCoalesce(options.transport, () => ( "direct"));
+    const taken = await this.#settings.store.take(hashToken(token), this.#settings.now());
+    const record = "record" in taken ? taken.record : void 0;
+    const inScope = this.#recordScope(record, transport, caller, void 0);
+    if (taken.status === "unknown" || taken.status === "consumed") {
+      await this.#reject(inScope, "confirmation_invalid", taken.status);
+      return false;
+    }
+    if (record && record.principalId !== caller.id) {
+      await this.#reject(inScope, "confirmation_invalid", "principal_mismatch");
+      return false;
+    }
+    await this.#record(inScope, { type: "confirmation.declined" });
+    return true;
+  }
+  /**
+   * Redeems a token: from `executeConfirmed` (`expected` absent) or from a
+   * repeated `callTool` (`expected` is that request, which must match).
+   * Everything is checked again, as if the call were new: the tool may have
+   * been removed and the principal's roles may have changed since.
+   */
+  async #redeem(caller, token, options, presented) {
+    const transport = _nullishCoalesce(options.transport, () => ( "direct"));
+    const now = this.#settings.now();
+    const taken = await this.#settings.store.take(hashToken(token), now);
+    const record = "record" in taken ? taken.record : void 0;
+    const inScope = this.#recordScope(record, transport, caller, presented);
+    if (taken.status === "unknown" || taken.status === "consumed") {
+      return this.#reject(inScope, "confirmation_invalid", taken.status);
+    }
+    if (record && record.principalId !== caller.id) {
+      return this.#reject(inScope, "confirmation_invalid", "principal_mismatch");
+    }
+    if (taken.status === "expired" || !record || now >= record.expiresAt) {
+      return this.#reject(inScope, "confirmation_expired", "expired");
+    }
+    if (presented) {
+      if (presented.name !== record.tool) {
+        return this.#reject(inScope, "confirmation_invalid", "tool_mismatch");
+      }
+      if (presented.args === void 0 || digestArguments(presented.args) !== record.argumentsDigest) {
+        return this.#reject(inScope, "confirmation_invalid", "arguments_mismatch");
+      }
+    }
+    const tool = this.registry.get(record.tool);
+    if (!tool) return this.#reject(inScope, "unknown_tool");
+    if (!canAccess(tool, caller)) return this.#reject(inScope, "forbidden");
+    let prepared;
+    try {
+      prepared = prepareCall(tool, record.arguments);
+    } catch (error) {
+      return this.#fail(inScope, true, 0, "exception", error);
+    }
+    if (!prepared.ok) return this.#rejectArguments(inScope, prepared.issues);
+    return this.#execute(inScope, tool, prepared, true, options.signal);
+  }
+  /** The audit scope of a redemption: the confirmed call when known, else what was presented. */
+  #recordScope(record, transport, caller, presented) {
+    const name = _nullishCoalesce(_nullishCoalesce(_optionalChain([record, 'optionalAccess', _5 => _5.tool]), () => ( _optionalChain([presented, 'optionalAccess', _6 => _6.name]))), () => ( ""));
+    const tool = this.registry.get(name);
+    if (record) {
+      return {
+        ...scope(record.callId, transport, caller, name, tool, record.arguments),
+        argsDigest: record.argumentsDigest
+      };
+    }
+    return scope(_crypto.randomUUID.call(void 0, ), transport, caller, name, tool, _optionalChain([presented, 'optionalAccess', _7 => _7.args]));
+  }
+  async #issue(scope2, tool, args, summary) {
+    const { store, ttlFor, now } = this.#settings;
+    const token = newToken();
+    const createdAt = now();
+    const record = Object.freeze({
+      tokenHash: hashToken(token),
+      callId: scope2.callId,
+      principalId: scope2.principal.id,
+      tool: tool.name,
+      arguments: _chunkXMYSMKGRcjs.deepFreeze.call(void 0, args),
+      argumentsDigest: digestArguments(args),
+      summary,
+      createdAt,
+      // Computed once, now, from this tool's class; stored with the record.
+      expiresAt: createdAt + ttlFor(tool)
+    });
+    try {
+      await store.put(record);
+    } catch (error) {
+      return this.#fail(scope2, false, 0, "exception", error);
+    }
+    const expiresAt = new Date(record.expiresAt).toISOString();
+    const recorded = await this.#record(scope2, { type: "confirmation.issued", expiresAt });
+    if (!recorded && this.#settings.blockOnAuditFailure) {
+      await store.take(record.tokenHash, now());
+      return { status: "tool_error", callId: scope2.callId, message: MESSAGES.auditUnavailable };
+    }
+    return {
+      status: "confirmation_required",
+      callId: scope2.callId,
+      confirmation: Object.freeze({ token, expiresAt, tool: tool.name, summary })
+    };
+  }
+  async #execute(scope2, tool, prepared, confirmed, signal) {
+    let context;
+    try {
+      context = await this.#settings.context(scope2.principal);
+    } catch (error) {
+      return this.#fail(scope2, confirmed, 0, "exception", error);
+    }
+    const recorded = await this.#record(scope2, { type: "call.started", confirmed });
+    if (!recorded && this.#settings.blockOnAuditFailure) {
+      return this.#fail(scope2, confirmed, 0, "audit_unavailable", void 0);
+    }
+    const startedAt = this.#settings.now();
+    const elapsed = () => Math.max(0, this.#settings.now() - startedAt);
+    let result;
+    try {
+      const output = await runWithLimits(
+        (abort) => prepared.run({
+          principal: scope2.principal,
+          context,
+          signal: abort,
+          callId: scope2.callId
+        }),
+        tool.timeoutMs,
+        signal
+      );
+      result = normalizeOutput(output);
+    } catch (error) {
+      if (error instanceof Timeout) return this.#fail(scope2, confirmed, elapsed(), "timeout", error);
+      if (error instanceof Cancelled)
+        return this.#fail(scope2, confirmed, elapsed(), "aborted", error);
+      if (error instanceof _chunkXMYSMKGRcjs.ToolError) {
+        return this.#fail(scope2, confirmed, elapsed(), "tool_error", error);
+      }
+      return this.#fail(scope2, confirmed, elapsed(), "exception", error);
+    }
+    if (!result) {
+      const invalid = new Error("the handler returned neither a string nor a valid ToolResult");
+      return this.#fail(scope2, confirmed, elapsed(), "exception", invalid);
+    }
+    await this.#record(scope2, {
+      type: "call.succeeded",
+      confirmed,
+      durationMs: elapsed(),
+      result: auditResult(result, scope2.keepResult)
+    });
+    return { status: "ok", callId: scope2.callId, result };
+  }
+  async #reject(scope2, reason, detail) {
+    await this.#record(
+      scope2,
+      detail === void 0 ? { type: "call.rejected", reason } : { type: "call.rejected", reason, detail }
+    );
+    const visible = reason === "forbidden" ? "unknown_tool" : reason;
+    return { status: "rejected", callId: scope2.callId, reason: visible };
+  }
+  async #rejectArguments(scope2, issues) {
+    await this.#record(scope2, { type: "call.rejected", reason: "invalid_arguments", issues });
+    return { status: "invalid_arguments", callId: scope2.callId, issues };
+  }
+  async #fail(scope2, confirmed, durationMs, kind, error) {
+    const full = kind === "audit_unavailable" ? MESSAGES.auditUnavailable : error instanceof Error ? error.message : String(error);
+    const detail = full.length > MAX_AUDITED_ERROR ? `${full.slice(0, MAX_AUDITED_ERROR)}\u2026` : full;
+    await this.#record(scope2, {
+      type: "call.failed",
+      confirmed,
+      durationMs,
+      error: { kind, message: detail }
+    });
+    return { status: "tool_error", callId: scope2.callId, message: publicMessage(kind, error) };
+  }
+  /** Writes to every sink. Returns false if any of them failed. */
+  async #record(scope2, body) {
+    const event = {
+      id: _crypto.randomUUID.call(void 0, ),
+      at: new Date(this.#settings.now()).toISOString(),
+      callId: scope2.callId,
+      transport: scope2.transport,
+      principal: { id: scope2.principal.id, roles: scope2.principal.roles },
+      tool: scope2.tool,
+      ...scope2.argsDigest === void 0 ? {} : { argsDigest: scope2.argsDigest },
+      ...scope2.keptArgs === void 0 ? {} : { args: scope2.keptArgs },
+      ...body
+    };
+    let ok = true;
+    for (const sink of this.#settings.sinks) {
+      try {
+        await sink.write(event);
+      } catch (error) {
+        ok = false;
+        process.emitWarning(
+          `mcp-tool-bridge: an audit sink failed on ${event.type}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return ok;
+  }
+};
+function publicMessage(kind, error) {
+  switch (kind) {
+    case "tool_error":
+      return error instanceof Error ? error.message : MESSAGES.exception;
+    case "timeout":
+      return error instanceof Timeout ? MESSAGES.timeout(error.ms) : MESSAGES.exception;
+    case "aborted":
+      return MESSAGES.aborted;
+    case "audit_unavailable":
+      return MESSAGES.auditUnavailable;
+    case "exception":
+      return MESSAGES.exception;
+  }
+}
+var Timeout = class extends Error {
+  
+  constructor(ms) {
+    super(`no answer within ${String(ms)} ms`);
+    this.ms = ms;
+  }
+};
+var Cancelled = class extends Error {
+  constructor() {
+    super("cancelled by the caller");
+  }
+};
+async function runWithLimits(run, timeoutMs, outer) {
+  const controller = new AbortController();
+  const cancel = () => {
+    controller.abort(new Cancelled());
+  };
+  if (_optionalChain([outer, 'optionalAccess', _8 => _8.aborted])) cancel();
+  else _optionalChain([outer, 'optionalAccess', _9 => _9.addEventListener, 'call', _10 => _10("abort", cancel, { once: true })]);
+  const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    controller.abort(new Timeout(timeoutMs));
+  }, timeoutMs);
+  const stopped = new Promise((_resolve, reject) => {
+    const stop = () => {
+      const reason = controller.signal.reason;
+      reject(reason instanceof Error ? reason : new Cancelled());
+    };
+    if (controller.signal.aborted) stop();
+    else controller.signal.addEventListener("abort", stop, { once: true });
+  });
+  try {
+    if (controller.signal.aborted) return await stopped;
+    return await Promise.race([run(controller.signal), stopped]);
+  } finally {
+    clearTimeout(timer);
+    _optionalChain([outer, 'optionalAccess', _11 => _11.removeEventListener, 'call', _12 => _12("abort", cancel)]);
+  }
+}
+function checkOptions(options) {
+  const raw = options;
+  if (typeof raw !== "object" || raw === null)
+    throw new TypeError("createBridge: options are required");
+  const { registry, context } = options;
+  if (!(_chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "registry") instanceof ToolRegistry)) {
+    throw new TypeError("createBridge: `registry` must be a ToolRegistry");
+  }
+  if (typeof _chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "context") !== "function") {
+    throw new TypeError(
+      "createBridge: `context` must be a function (use `() => undefined` if tools need none)"
+    );
+  }
+  const confirmation = _nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "confirmation"), () => ( {}));
+  if (typeof confirmation !== "object" || confirmation === null) {
+    throw new TypeError("createBridge: `confirmation` must be an object");
+  }
+  const threshold = _nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, confirmation, "threshold"), () => ( DEFAULT_POLICY.threshold));
+  if (!isConfirmationThreshold(threshold)) {
+    throw new TypeError(
+      "createBridge: `confirmation.threshold` must be low, medium, high or critical"
+    );
+  }
+  const lowers = _nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, confirmation, "irreversibleLowersThreshold"), () => ( DEFAULT_POLICY.irreversibleLowersThreshold));
+  if (typeof lowers !== "boolean") {
+    throw new TypeError(
+      "createBridge: `confirmation.irreversibleLowersThreshold` must be a boolean"
+    );
+  }
+  const ttlFor = checkTtl(_chunkXMYSMKGRcjs.readProperty.call(void 0, confirmation, "ttlMs"));
+  const now = _chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "now");
+  if (now !== void 0 && typeof now !== "function") {
+    throw new TypeError("createBridge: `now` must be a function");
+  }
+  const clock = _nullishCoalesce(options.now, () => ( Date.now));
+  const store = _nullishCoalesce(_optionalChain([options, 'access', _13 => _13.confirmation, 'optionalAccess', _14 => _14.store]), () => ( new MemoryConfirmationStore({ now: clock })));
+  if (!hasMethods(store, ["put", "take"])) {
+    throw new TypeError("createBridge: `confirmation.store` must implement put() and take()");
+  }
+  const audit = _chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "audit");
+  const sinks = audit === void 0 ? [stderrJsonSink()] : Array.isArray(audit) ? audit : [audit];
+  const checkedSinks = [];
+  for (const sink of sinks) {
+    if (!isSink(sink))
+      throw new TypeError("createBridge: every audit sink must have a write() method");
+    checkedSinks.push(sink);
+  }
+  const auditFailure = _nullishCoalesce(_chunkXMYSMKGRcjs.readProperty.call(void 0, raw, "auditFailure"), () => ( "continue"));
+  if (auditFailure !== "continue" && auditFailure !== "block") {
+    throw new TypeError('createBridge: `auditFailure` must be "continue" or "block"');
+  }
+  return {
+    registry,
+    context,
+    policy: Object.freeze({ threshold, irreversibleLowersThreshold: lowers }),
+    ttlFor,
+    store,
+    sinks: Object.freeze(checkedSinks),
+    blockOnAuditFailure: auditFailure === "block",
+    now: clock
+  };
+}
+function checkTtl(value) {
+  const duration = (v, where) => {
+    if (typeof v !== "number" || !Number.isSafeInteger(v) || v <= 0) {
+      throw new TypeError(
+        `createBridge: \`confirmation.ttlMs${where}\` must be a positive integer of milliseconds`
+      );
+    }
+    return v;
+  };
+  if (value === void 0) return () => DEFAULT_TTL_MS;
+  if (typeof value === "number") {
+    const ms = duration(value, "");
+    return () => ms;
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError(
+      "createBridge: `confirmation.ttlMs` must be a number or a table per sensitivity"
+    );
+  }
+  const table = /* @__PURE__ */ new Map();
+  for (const level of Object.keys(value)) {
+    if (!isSensitivity(level)) {
+      throw new TypeError(
+        `createBridge: \`confirmation.ttlMs\` has an unknown sensitivity ${JSON.stringify(level)}`
+      );
+    }
+    const row = _chunkXMYSMKGRcjs.readProperty.call(void 0, value, level);
+    if (typeof row !== "object" || row === null) {
+      throw new TypeError(
+        `createBridge: \`confirmation.ttlMs.${level}\` must be { reversible?, irreversible? }`
+      );
+    }
+    for (const kind of Object.keys(row)) {
+      if (kind !== "reversible" && kind !== "irreversible") {
+        throw new TypeError(
+          `createBridge: \`confirmation.ttlMs.${level}.${kind}\` is not reversible or irreversible`
+        );
+      }
+      table.set(`${level}:${kind}`, duration(_chunkXMYSMKGRcjs.readProperty.call(void 0, row, kind), `.${level}.${kind}`));
+    }
+  }
+  return (tool) => _nullishCoalesce(table.get(`${tool.sensitivity}:${tool.reversible ? "reversible" : "irreversible"}`), () => ( DEFAULT_TTL_MS));
+}
+function hasMethods(value, methods) {
+  if (typeof value !== "object" || value === null) return false;
+  return methods.every((method) => typeof _chunkXMYSMKGRcjs.readProperty.call(void 0, value, method) === "function");
+}
+function isSink(value) {
+  return hasMethods(value, ["write"]);
+}
+
+// src/server/mcpServer.ts
+var _indexjs = require('@modelcontextprotocol/sdk/server/index.js');
+
+
+
+
+
+var _typesjs = require('@modelcontextprotocol/sdk/types.js');
+var CONFIRMATION_META_KEY = "mcp-tool-bridge/confirmation";
+function createMcpServer(bridge, options) {
+  const principal = parsePrincipal(options.principal);
+  const transport = _nullishCoalesce(options.transport, () => ( "direct"));
+  const elicit = _nullishCoalesce(options.elicitConfirmations, () => ( true));
+  const { name, version, title, instructions } = options.info;
+  const server = new (0, _indexjs.Server)(title === void 0 ? { name, version } : { name, version, title }, {
+    capabilities: { tools: { listChanged: true } },
+    ...instructions === void 0 ? {} : { instructions }
+  });
+  server.setRequestHandler(_typesjs.ListToolsRequestSchema, () => ({
+    tools: bridge.listTools(principal).map(toMcpTool)
+  }));
+  server.setRequestHandler(_typesjs.CallToolRequestSchema, async (request, extra) => {
+    const { name: tool, arguments: args, _meta } = request.params;
+    const token = confirmationTokenOf(_meta);
+    const callOptions = { signal: extra.signal, transport };
+    const outcome = await bridge.callTool(
+      principal,
+      token === void 0 ? { name: tool, arguments: args } : { name: tool, arguments: args, confirmationToken: token },
+      callOptions
+    );
+    if (outcome.status === "confirmation_required" && elicit && canElicit(server)) {
+      return confirmWithUser(server, bridge, principal, outcome, callOptions);
+    }
+    return toCallToolResult(outcome, tool);
+  });
+  const unsubscribe = bridge.registry.onChange(() => {
+    server.sendToolListChanged().catch(() => void 0);
+  });
+  const previousOnClose = server.onclose;
+  server.onclose = () => {
+    unsubscribe();
+    _optionalChain([previousOnClose, 'optionalCall', _15 => _15()]);
+  };
+  return server;
+}
+async function confirmWithUser(server, bridge, principal, outcome, options) {
+  const { confirmation } = outcome;
+  let answer;
+  try {
+    answer = await server.elicitInput(
+      {
+        message: `Allow this action? ${confirmation.summary}`,
+        requestedSchema: {
+          type: "object",
+          properties: {
+            confirm: {
+              type: "boolean",
+              title: "Allow",
+              description: confirmation.summary,
+              default: false
+            }
+          },
+          required: ["confirm"]
+        }
+      },
+      {
+        // A person may take a while: wait as long as the confirmation lives.
+        timeout: Math.max(1, Date.parse(confirmation.expiresAt) - Date.now()),
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+  } catch (e) {
+    return pendingResult(outcome.callId, confirmation);
+  }
+  if (answer.action === "accept" && _optionalChain([answer, 'access', _16 => _16.content, 'optionalAccess', _17 => _17.confirm]) === true) {
+    const executed = await bridge.executeConfirmed(principal, confirmation.token, options);
+    return toCallToolResult(executed, confirmation.tool);
+  }
+  await bridge.revokeConfirmation(principal, confirmation.token, options);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `The user declined: ${confirmation.summary}. Nothing was done. Do not try again unless they ask.`
+      }
+    ],
+    structuredContent: { status: "declined", tool: confirmation.tool }
+  };
+}
+function canElicit(server) {
+  const elicitation = _optionalChain([server, 'access', _18 => _18.getClientCapabilities, 'call', _19 => _19(), 'optionalAccess', _20 => _20.elicitation]);
+  if (elicitation === void 0) return false;
+  return elicitation.form !== void 0 || elicitation.url === void 0;
+}
+function confirmationTokenOf(meta) {
+  if (typeof meta !== "object" || meta === null) return void 0;
+  const entry = _chunkXMYSMKGRcjs.readProperty.call(void 0, meta, CONFIRMATION_META_KEY);
+  if (typeof entry !== "object" || entry === null) return void 0;
+  const token = _chunkXMYSMKGRcjs.readProperty.call(void 0, entry, "token");
+  return typeof token === "string" ? token : void 0;
+}
+function toCallToolResult(outcome, tool) {
+  switch (outcome.status) {
+    case "ok":
+      return fromToolResult(outcome.result);
+    case "tool_error":
+      return errorResult(outcome.message);
+    case "invalid_arguments":
+      return errorResult(describeIssues(tool, outcome.issues));
+    case "confirmation_required":
+      return pendingResult(outcome.callId, outcome.confirmation);
+    case "rejected":
+      switch (outcome.reason) {
+        case "unknown_tool":
+          throw new (0, _typesjs.McpError)(_typesjs.ErrorCode.InvalidParams, `Unknown tool: ${tool}`);
+        case "confirmation_expired":
+        case "confirmation_invalid":
+          return errorResult(CONFIRMATION_REFUSED);
+      }
+  }
+}
+function pendingResult(callId, confirmation) {
+  const { token, expiresAt, tool, summary } = confirmation;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Confirmation required: ${summary}. Nothing has been done yet. The user must confirm this action in the application before ${expiresAt}; calling the tool again does not confirm it.`
+      }
+    ],
+    structuredContent: { status: "confirmation_required", tool, summary, expiresAt },
+    _meta: { [CONFIRMATION_META_KEY]: { token, expiresAt, callId } }
+  };
+}
+var CONFIRMATION_REFUSED = "This confirmation cannot be used. Nothing was done.";
+function errorResult(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function describeIssues(tool, issues) {
+  const lines = issues.map(
+    (issue) => `- ${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`
+  );
+  return [`Invalid arguments for ${tool}:`, ...lines].join("\n");
+}
+function fromToolResult(result) {
+  return {
+    content: result.content.map((block) => ({ ...block })),
+    ...result.structuredContent === void 0 ? {} : { structuredContent: { ...result.structuredContent } },
+    ...result.isError === void 0 ? {} : { isError: result.isError }
+  };
+}
+function toMcpTool(tool) {
+  const { readOnlyHint, destructiveHint } = tool.annotations;
+  return {
+    name: tool.name,
+    ...tool.title === void 0 ? {} : { title: tool.title },
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: {
+      ...tool.title === void 0 ? {} : { title: tool.title },
+      readOnlyHint,
+      destructiveHint
+    }
+  };
+}
+
+// src/server/stdio.ts
+var _stdiojs = require('@modelcontextprotocol/sdk/server/stdio.js');
+async function serveStdio(bridge, options) {
+  const server = createMcpServer(bridge, { ...options, transport: "stdio" });
+  await server.connect(new (0, _stdiojs.StdioServerTransport)());
+  return {
+    server,
+    close: () => server.close()
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CONFIRMATION_META_KEY = CONFIRMATION_META_KEY; exports.MemoryConfirmationStore = MemoryConfirmationStore; exports.REDACTED = REDACTED; exports.SENSITIVITY_LEVELS = SENSITIVITY_LEVELS; exports.ToolDefinitionError = _chunkXMYSMKGRcjs.ToolDefinitionError; exports.ToolError = _chunkXMYSMKGRcjs.ToolError; exports.ToolRegistry = ToolRegistry; exports.adapt = adapt; exports.canAccess = canAccess; exports.createBridge = createBridge; exports.createMcpServer = createMcpServer; exports.defineTool = defineTool; exports.envelope = envelope; exports.exposeTool = exposeTool; exports.importDefinitions = importDefinitions; exports.isSecretKey = isSecretKey; exports.isSensitivity = isSensitivity; exports.isTool = isTool; exports.json = json; exports.jsonSchema = jsonSchema; exports.memorySink = memorySink; exports.parsePrincipal = parsePrincipal; exports.requiresConfirmation = requiresConfirmation; exports.sensitivityRank = sensitivityRank; exports.serveStdio = serveStdio; exports.stderrJsonSink = stderrJsonSink; exports.text = text; exports.visibleTools = visibleTools;