ofw-mcp 2.20.1 → 2.20.2

package/dist/bundle.js

@@ -2335,11 +2335,23 @@ var require_websocket = __commonJS({
           this._isServer = false;
           this._redirects = 0;
           if (protocols === void 0) {
-            protocols = [];
+            if (!options || options.protocols === void 0) {
+              protocols = [];
+            } else if (Array.isArray(options.protocols)) {
+              protocols = options.protocols;
+            } else {
+              protocols = [options.protocols];
+            }
           } else if (!Array.isArray(protocols)) {
             if (typeof protocols === "object" && protocols !== null) {
               options = protocols;
-              protocols = [];
+              if (options.protocols === void 0) {
+                protocols = [];
+              } else if (Array.isArray(options.protocols)) {
+                protocols = options.protocols;
+              } else {
+                protocols = [options.protocols];
+              }
             } else {
               protocols = [protocols];
             }
@@ -2536,7 +2548,6 @@ var require_websocket = __commonJS({
           }
           return;
         }
-        this._readyState = _WebSocket.CLOSING;
         this._sender.close(code2, data, !this._isServer, (err) => {
           if (err) return;
           this._closeFrameSent = true;
@@ -2544,6 +2555,7 @@ var require_websocket = __commonJS({
             this._socket.end();
           }
         });
+        this._readyState = _WebSocket.CLOSING;
         setCloseTimer(this);
       }
       /**
@@ -2768,6 +2780,7 @@ var require_websocket = __commonJS({
         socketPath: void 0,
         hostname: void 0,
         protocol: void 0,
+        protocols: void 0,
         timeout: void 0,
         method: "GET",
         host: void 0,
@@ -21552,8 +21565,8 @@ function currencyCode2(_params) {
   return _stringFormat(ZodCustomStringFormat, "currency_code", currencyCode, _params);
 }
 function hash(alg, params) {
-  const enc6 = params?.enc ?? "hex";
-  const format = `${alg}_${enc6}`;
+  const enc7 = params?.enc ?? "hex";
+  const format = `${alg}_${enc7}`;
   const regex = regexes_exports[format];
   if (!regex)
     throw new Error(`Unrecognized hash format: ${format}`);
@@ -24428,7 +24441,7 @@ var OAuthTokenRevocationRequestSchema = object({
   token_type_hint: string2().optional()
 }).strip();
 
-// node_modules/@modelcontextprotocol/server/dist/src-BHSMhZ_W.mjs
+// node_modules/@modelcontextprotocol/server/dist/src-Cqbh3MYc.mjs
 var BRANDS = /* @__PURE__ */ Symbol.for("mcp.sdk.errorBrands");
 function stampErrorBrands(instance, ctor) {
   const brands = /* @__PURE__ */ new Set();
@@ -26671,7 +26684,8 @@ function build() {
     ListResourceTemplatesResultResponseSchema: wireResultResponse(ListResourceTemplatesResultSchema$1),
     ReadResourceResultResponseSchema: wireResultResponse(union([ReadResourceResultSchema$1, InputRequiredResultSchema])),
     CompleteResultResponseSchema: wireResultResponse(CompleteResultSchema$1),
-    DiscoverResultResponseSchema: wireResultResponse(DiscoverResultSchema$1)
+    DiscoverResultResponseSchema: wireResultResponse(DiscoverResultSchema$1),
+    SubscriptionsListenResultResponseSchema: wireResultResponse(SubscriptionsListenResultSchema$1)
   };
 }
 var memo2;
@@ -27179,6 +27193,9 @@ function isSpecRequestMethod(method) {
 function isSpecNotificationMethod(method) {
   return ALL_CODECS.some((codec2) => codec2.hasNotificationMethod(method));
 }
+function isExtensionReusedRequestMethod(method) {
+  return method === "tasks/get" || method === "tasks/cancel";
+}
 var ALL_CODECS = [rev2025Codec, rev2026Codec];
 function isPlainObject$3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -28187,6 +28204,8 @@ var Protocol = class {
   _transport;
   _requestMessageId = 0;
   _requestHandlers = /* @__PURE__ */ new Map();
+  /** Methods registered with an explicit schema; the era gate in `_onrequest` reads it for the Tasks extension names. */
+  _customSchemaRequestMethods = /* @__PURE__ */ new Set();
   _requestHandlerAbortControllers = /* @__PURE__ */ new Map();
   _notificationHandlers = /* @__PURE__ */ new Map();
   _responseHandlers = /* @__PURE__ */ new Map();
@@ -28470,7 +28489,7 @@ var Protocol = class {
         return;
       }
     }
-    if (isSpecRequestMethod(request.method) && !codec2.hasRequestMethod(request.method)) {
+    if (isSpecRequestMethod(request.method) && !codec2.hasRequestMethod(request.method) && !(isExtensionReusedRequestMethod(request.method) && this._customSchemaRequestMethods.has(request.method))) {
       sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
       return;
     }
@@ -28603,8 +28622,11 @@ var Protocol = class {
   }
   request(request, schemaOrOptions, maybeOptions) {
     const codec2 = this._resolveOutboundCodec(request.method);
+    if (isStandardSchema(schemaOrOptions)) {
+      if (!isExtensionReusedRequestMethod(request.method)) this._assertOutboundRequestInEra(codec2, request.method);
+      return this._requestWithSchemaViaCodec(codec2, request, schemaOrOptions, maybeOptions);
+    }
     this._assertOutboundRequestInEra(codec2, request.method);
-    if (isStandardSchema(schemaOrOptions)) return this._requestWithSchemaViaCodec(codec2, request, schemaOrOptions, maybeOptions);
     const validate2 = codecResultValidator(codec2, request.method);
     if (validate2 === void 0) throw new TypeError(`'${request.method}' is not a spec method; pass a result schema as the second argument to request().`);
     return this._requestWithSchemaViaCodec(codec2, request, validate2, schemaOrOptions);
@@ -28848,6 +28870,8 @@ var Protocol = class {
       return maybeHandler(parsed.data, ctx);
     };
     else throw new TypeError("setRequestHandler: handler is required");
+    if (typeof schemasOrHandler === "function") this._customSchemaRequestMethods.delete(method);
+    else this._customSchemaRequestMethods.add(method);
     this._requestHandlers.set(method, this._wrapHandler(method, stored));
   }
   /**
@@ -28877,6 +28901,7 @@ var Protocol = class {
   */
   removeRequestHandler(method) {
     this._requestHandlers.delete(method);
+    this._customSchemaRequestMethods.delete(method);
   }
   /**
   * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
@@ -36119,7 +36144,7 @@ var Ajv = import_ajv.Ajv;
 // node_modules/@modelcontextprotocol/server/dist/shimsNode.mjs
 import process2 from "node:process";
 
-// node_modules/@modelcontextprotocol/server/dist/mcp-DYuW2ZSs.mjs
+// node_modules/@modelcontextprotocol/server/dist/mcp-DIH4cS6P.mjs
 var COMPLETABLE_SYMBOL = /* @__PURE__ */ Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
@@ -36184,7 +36209,7 @@ var StdioListenRouter = class {
   _serverCapabilities;
   /**
   * The serving instance's identity, stamped onto the graceful-close
-  * results' `_meta` (the spec's `SubscriptionsListenResultMeta` extends
+  * results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends
   * `ResultMetaObject`). Handed over together with the capabilities.
   */
   _serverInfo;
@@ -36516,6 +36541,11 @@ var Server = class extends Protocol {
     if (modernProtocolVersions(this._supportedProtocolVersions).length > 0) this.setRequestHandler("server/discover", () => this._ondiscover());
     if (this._capabilities.logging) this._registerLoggingHandler();
   }
+  /** Attaches to the given transport; rejects while this instance is connected to another one. */
+  async connect(transport) {
+    if (this.transport !== void 0) throw new SdkError(SdkErrorCode.AlreadyConnected, "Use a separate Server instance per connection: this instance is already connected to a transport. To connect it to a new transport, call close() first.");
+    await super.connect(transport);
+  }
   /**
   * Registers the built-in `logging/setLevel` request handler.
   *
@@ -37069,21 +37099,41 @@ var Server = class extends Protocol {
 function discoverAdvertisedCapabilities(capabilities) {
   return { ...capabilities };
 }
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node2 = stack.pop();
+    if (node2 === null || typeof node2 !== "object") continue;
+    if (Array.isArray(node2)) for (const child of node2) {
+      if (++count > max) return count;
+      if (child !== null && typeof child === "object") stack.push(child);
+    }
+    else for (const key in node2) {
+      if (!Object.prototype.hasOwnProperty.call(node2, key)) continue;
+      if (++count > max) return count;
+      const child = node2[key];
+      if (child !== null && typeof child === "object") stack.push(child);
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === void 0 || value === Infinity) return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  return value;
+}
 var McpServer = class {
   /**
   * The underlying {@linkcode Server} instance, useful for advanced operations like sending notifications.
   */
   server;
+  _maxToolInputElements;
   _registeredResources = {};
   _registeredResourceTemplates = {};
   _registeredTools = {};
   _registeredPrompts = {};
-  /**
-  * Per-tool JSON-converted `inputSchema`, memoized so the SEP-2243
-  * registration-time scan and the pre-dispatch validation step share one
-  * conversion instead of paying it twice per request under the
-  * per-request-factory `createMcpHandler` model.
-  */
+  /** Per-tool JSON-converted `inputSchema`, filled on first use by `toolInputSchemaJson()`. */
   _toolInputSchemaJson = {};
   /**
   * The JSON-serialized `inputSchema` of a registered tool, or `undefined`
@@ -37108,6 +37158,7 @@ var McpServer = class {
   }
   constructor(serverInfo, options) {
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
     if (options?.capabilities?.tools) this.setToolRequestHandlers();
     if (options?.capabilities?.resources) this.setResourceRequestHandlers();
     if (options?.capabilities?.prompts) this.setPromptRequestHandlers();
@@ -37180,7 +37231,7 @@ var McpServer = class {
         name,
         title: tool.title,
         description: tool.description,
-        inputSchema: tool.inputSchema ? standardSchemaToJsonSchema(tool.inputSchema, "input") : EMPTY_OBJECT_JSON_SCHEMA,
+        inputSchema: tool.inputSchema ? convertListedInputSchema(name, tool.inputSchema) : EMPTY_OBJECT_JSON_SCHEMA,
         annotations: tool.annotations,
         icons: tool.icons,
         execution: tool.execution,
@@ -37225,6 +37276,7 @@ var McpServer = class {
   * Validates tool input arguments against the tool's input schema.
   */
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== void 0 && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
     if (!tool.inputSchema) return;
     const parseResult = await validateStandardSchema(tool.inputSchema, args ?? {});
     if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${parseResult.error}`);
@@ -37499,20 +37551,19 @@ var McpServer = class {
   }
   _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, icons, execution, scopeChallenge, _meta, handler) {
     validateAndWarnToolName(name);
-    if (inputSchema !== void 0) try {
-      const json2 = standardSchemaToJsonSchema(inputSchema, "input");
-      this._toolInputSchemaJson[name] = json2;
-      const scan = scanXMcpHeaderDeclarations(json2);
-      if (!scan.valid) console.warn(`[mcp-sdk] tool '${name}' carries an invalid x-mcp-header declaration and will be excluded by conforming Streamable HTTP clients: ${scan.reason}`);
-    } catch {
-    }
     let currentHandler = handler;
+    let outputSchemaJson;
     const registeredTool = {
       title,
       description,
       inputSchema,
       outputSchema,
-      outputSchemaJson: convertOutputSchemaJson(outputSchema),
+      get outputSchemaJson() {
+        return outputSchemaJson ??= convertOutputSchemaJson(registeredTool.outputSchema);
+      },
+      set outputSchemaJson(value) {
+        outputSchemaJson = value;
+      },
       annotations,
       icons,
       execution,
@@ -37639,6 +37690,12 @@ var EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
 };
+function convertListedInputSchema(name, inputSchema) {
+  const json2 = standardSchemaToJsonSchema(inputSchema, "input");
+  const scan = scanXMcpHeaderDeclarations(json2);
+  if (!scan.valid) console.warn(`[mcp-sdk] tool '${name}' carries an invalid x-mcp-header declaration and will be excluded by conforming Streamable HTTP clients: ${scan.reason}`);
+  return json2;
+}
 function convertOutputSchemaJson(outputSchema) {
   if (outputSchema === void 0) return void 0;
   try {
@@ -37651,7 +37708,7 @@ function createPromptHandler(name, argsSchema, callback) {
   if (argsSchema) {
     const typedCallback = callback;
     return async (args, ctx) => {
-      const parseResult = await validateStandardSchema(argsSchema, args);
+      const parseResult = await validateStandardSchema(argsSchema, args ?? {});
       if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for prompt ${name}: ${parseResult.error}`);
       return typedCallback(parseResult.data, ctx);
     };
@@ -38999,7 +39056,10 @@ function surfaceToolHints(server) {
   ));
 }
 async function createMcpServer(opts) {
-  const server = new McpServer({ name: opts.name, version: opts.version }, { supportedProtocolVersions: [...SERVER_PROTOCOL_VERSIONS] });
+  const server = new McpServer({ name: opts.name, version: opts.version }, {
+    supportedProtocolVersions: [...SERVER_PROTOCOL_VERSIONS],
+    ...opts.maxToolInputElements !== void 0 ? { maxToolInputElements: opts.maxToolInputElements } : {}
+  });
   if (opts.surfaceHints !== false)
     surfaceToolHints(server);
   if (opts.banner !== void 0) {
@@ -40327,6 +40387,49 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "graphql",
   "write_cookies"
 ]);
+var ACCOUNT_KEY_FRAME = "account-key";
+var ACCOUNT_ATTEST_FRAME = "account-attest";
+
+// node_modules/@fetchproxy/protocol/dist/mcp-id.js
+var ID_RE = /^([^:]+):([^:]+):([0-9a-f]{16})$/;
+function generateMcpId(serverName, version2) {
+  if (serverName.includes(":")) {
+    throw new Error(`serverName cannot contain ':': ${serverName}`);
+  }
+  if (version2.includes(":")) {
+    throw new Error(`version cannot contain ':': ${version2}`);
+  }
+  const rand = randomHex(8);
+  return `${serverName}:${version2}:${rand}`;
+}
+function isValidMcpId(id) {
+  return typeof id === "string" && ID_RE.test(id);
+}
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  globalThis.crypto.getRandomValues(arr);
+  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// node_modules/@fetchproxy/protocol/dist/account-attest.js
+var ACCOUNT_ATTEST_CONSENTS = Object.freeze([
+  "silent",
+  "confirm",
+  "confirm-each"
+]);
+var NO_SCOPE_DIGEST = "0".repeat(64);
+var ACCOUNT_ID_RE = /^[A-Za-z0-9_.\-]{1,128}$/;
+var HEX64_RE = /^[0-9a-f]{64}$/;
+var ACCOUNT_KID_RE = /^[0-9a-f]{16}$/;
+var enc2 = new TextEncoder();
+
+// node_modules/@fetchproxy/protocol/dist/awaiting-approval.js
+var AWAITING_APPROVAL_REASON_PREFIX = "awaiting-approval:";
+function parseAwaitingApprovalReason(reason) {
+  if (!reason.startsWith(AWAITING_APPROVAL_REASON_PREFIX))
+    return null;
+  return reason.slice(AWAITING_APPROVAL_REASON_PREFIX.length).trim();
+}
 
 // node_modules/@fetchproxy/protocol/dist/capability-availability.js
 var CAPABILITY_UNAVAILABLE_CODE = "capability_unavailable";
@@ -40352,27 +40455,6 @@ function parseUnsupportedCapabilityReason(reason) {
   return rest.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
 
-// node_modules/@fetchproxy/protocol/dist/mcp-id.js
-var ID_RE = /^([^:]+):([^:]+):([0-9a-f]{16})$/;
-function generateMcpId(serverName, version2) {
-  if (serverName.includes(":")) {
-    throw new Error(`serverName cannot contain ':': ${serverName}`);
-  }
-  if (version2.includes(":")) {
-    throw new Error(`version cannot contain ':': ${version2}`);
-  }
-  const rand = randomHex(8);
-  return `${serverName}:${version2}:${rand}`;
-}
-function isValidMcpId(id) {
-  return typeof id === "string" && ID_RE.test(id);
-}
-function randomHex(bytes) {
-  const arr = new Uint8Array(bytes);
-  globalThis.crypto.getRandomValues(arr);
-  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-
 // node_modules/@fetchproxy/protocol/dist/json-pointer.js
 function matchesDeclaredKey(requested, declared) {
   for (const decl of declared) {
@@ -40968,6 +41050,10 @@ function validateFrame(raw) {
     return { type: "extension-disconnected" };
   if (t === "peer-gone")
     return validatePeerGone(raw);
+  if (t === ACCOUNT_KEY_FRAME)
+    return validateAccountKey(raw);
+  if (t === ACCOUNT_ATTEST_FRAME)
+    return validateAccountAttest(raw);
   throw new ProtocolError3(`unknown frame type: ${String(t)}`);
 }
 function validateHello(raw) {
@@ -41171,6 +41257,128 @@ function validateHelloRejected(raw) {
   }
   return { type: "hello-rejected", mcpId: raw.mcpId, reason: raw.reason };
 }
+var DISPLAY_FORBIDDEN_RE = /[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+function assertExactFields(raw, allowed, label) {
+  for (const k of Object.keys(raw)) {
+    if (!allowed.includes(k)) {
+      throw new ProtocolError3(`${label}: unexpected field ${JSON.stringify(k)}`);
+    }
+  }
+}
+function assertMatch(x, re, label, what) {
+  assertString(x, label);
+  if (!re.test(x))
+    throw new ProtocolError3(`${label}: must be ${what}`);
+}
+function assertPositiveSafeInt(x, label) {
+  if (typeof x !== "number" || !Number.isSafeInteger(x) || x <= 0) {
+    throw new ProtocolError3(`${label}: expected positive safe integer`);
+  }
+}
+function assertDisplayString(x, label, min, max) {
+  assertString(x, label);
+  if (x.length < min || x.length > max) {
+    throw new ProtocolError3(`${label}: must be ${min}-${max} characters`);
+  }
+  if (DISPLAY_FORBIDDEN_RE.test(x)) {
+    throw new ProtocolError3(`${label}: control or bidi-override character`);
+  }
+}
+var ACCOUNT_KEY_FIELDS = [
+  "type",
+  "accountId",
+  "slug",
+  "displayName",
+  "confirmedBy",
+  "tokenId",
+  "kid",
+  "publicKey",
+  "generation",
+  "bridgedRegistrations"
+];
+function validateAccountKey(raw) {
+  const L = "account-key";
+  assertMatch(raw.accountId, ACCOUNT_ID_RE, `${L}.accountId`, "an account id");
+  assertMatch(raw.slug, ACCOUNT_ID_RE, `${L}.slug`, "a slug");
+  assertDisplayString(raw.displayName, `${L}.displayName`, 0, 128);
+  assertDisplayString(raw.confirmedBy, `${L}.confirmedBy`, 1, 256);
+  assertMatch(raw.tokenId, ACCOUNT_ID_RE, `${L}.tokenId`, "a token id");
+  assertMatch(raw.kid, ACCOUNT_KID_RE, `${L}.kid`, "16 lowercase hex");
+  assertBase64Bytes(raw.publicKey, `${L}.publicKey`, 32);
+  assertPositiveSafeInt(raw.generation, `${L}.generation`);
+  const n = raw.bridgedRegistrations;
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0) {
+    throw new ProtocolError3(`${L}.bridgedRegistrations: expected non-negative safe integer`);
+  }
+  assertExactFields(raw, ACCOUNT_KEY_FIELDS, L);
+  return {
+    type: ACCOUNT_KEY_FRAME,
+    accountId: raw.accountId,
+    slug: raw.slug,
+    displayName: raw.displayName,
+    confirmedBy: raw.confirmedBy,
+    tokenId: raw.tokenId,
+    kid: raw.kid,
+    publicKey: raw.publicKey,
+    generation: raw.generation,
+    bridgedRegistrations: n
+  };
+}
+var ACCOUNT_ATTEST_FIELDS = [
+  "type",
+  "mcpId",
+  "accountId",
+  "generation",
+  "tokenId",
+  "kid",
+  "registrationId",
+  "slug",
+  "identityHash",
+  "identityEd25519Pub",
+  "scopeDigest",
+  "consent",
+  "notAfter",
+  "sig"
+];
+function validateAccountAttest(raw) {
+  const L = "account-attest";
+  if (!isValidMcpId(raw.mcpId))
+    throw new ProtocolError3(`${L}.mcpId: invalid format`);
+  assertMatch(raw.accountId, ACCOUNT_ID_RE, `${L}.accountId`, "an account id");
+  assertPositiveSafeInt(raw.generation, `${L}.generation`);
+  assertMatch(raw.tokenId, ACCOUNT_ID_RE, `${L}.tokenId`, "a token id");
+  assertMatch(raw.kid, ACCOUNT_KID_RE, `${L}.kid`, "16 lowercase hex");
+  assertMatch(raw.registrationId, ACCOUNT_ID_RE, `${L}.registrationId`, "a registration id");
+  assertMatch(raw.slug, ACCOUNT_ID_RE, `${L}.slug`, "a slug");
+  assertMatch(raw.identityHash, HEX64_RE, `${L}.identityHash`, "64 lowercase hex");
+  assertBase64Bytes(raw.identityEd25519Pub, `${L}.identityEd25519Pub`, 32);
+  assertMatch(raw.scopeDigest, HEX64_RE, `${L}.scopeDigest`, "64 lowercase hex");
+  assertString(raw.consent, `${L}.consent`);
+  const consent = raw.consent;
+  const known = ACCOUNT_ATTEST_CONSENTS.find((c) => c === consent);
+  if (known === void 0) {
+    throw new ProtocolError3(`${L}.consent: must be one of ${ACCOUNT_ATTEST_CONSENTS.join(", ")}`);
+  }
+  assertPositiveSafeInt(raw.notAfter, `${L}.notAfter`);
+  assertBase64Bytes(raw.sig, `${L}.sig`, 64);
+  assertExactFields(raw, ACCOUNT_ATTEST_FIELDS, L);
+  return {
+    type: ACCOUNT_ATTEST_FRAME,
+    mcpId: raw.mcpId,
+    accountId: raw.accountId,
+    generation: raw.generation,
+    tokenId: raw.tokenId,
+    kid: raw.kid,
+    registrationId: raw.registrationId,
+    slug: raw.slug,
+    identityHash: raw.identityHash,
+    identityEd25519Pub: raw.identityEd25519Pub,
+    scopeDigest: raw.scopeDigest,
+    consent: known,
+    notAfter: raw.notAfter,
+    sig: raw.sig
+  };
+}
 function validateInnerFrame(raw) {
   assertObject(raw, "inner");
   const t = raw.type;
@@ -41638,10 +41846,10 @@ function validateInnerResponse(raw) {
 }
 
 // node_modules/@fetchproxy/protocol/dist/pair-code.js
-var enc2 = new TextEncoder();
+var enc3 = new TextEncoder();
 var PAIR_LABEL = "fetchproxy/4/pair";
 async function pairTranscript(mcpIdentityPub, extIdentityPub, mcpNonce, extNonce, mcpSessionPub) {
-  const label = enc2.encode(PAIR_LABEL);
+  const label = enc3.encode(PAIR_LABEL);
   const parts = [mcpIdentityPub, extIdentityPub, mcpNonce, extNonce, mcpSessionPub];
   const out = new Uint8Array(label.length + 1 + parts.reduce((n, p) => n + p.length, 0));
   out.set(label, 0);
@@ -41662,7 +41870,7 @@ function digits(hash2) {
 }
 
 // node_modules/@fetchproxy/protocol/dist/seal.js
-var enc3 = new TextEncoder();
+var enc4 = new TextEncoder();
 var dec = new TextDecoder();
 function randomIv() {
   const iv = new Uint8Array(12);
@@ -41675,14 +41883,14 @@ function base64Length(byteLength) {
   return Math.ceil(byteLength / 3) * 4;
 }
 function encodeInnerFrame(inner) {
-  return enc3.encode(JSON.stringify(inner));
+  return enc4.encode(JSON.stringify(inner));
 }
 function plaintextOf(inner) {
   return inner instanceof Uint8Array ? inner : encodeInnerFrame(inner);
 }
 function sealedFrameWireBytes(mcpId, seq, inner) {
   const plaintext = plaintextOf(inner).length;
-  const envelope = enc3.encode(JSON.stringify({ type: "frame", mcpId, seq, iv: "", ciphertext: "" })).length;
+  const envelope = enc4.encode(JSON.stringify({ type: "frame", mcpId, seq, iv: "", ciphertext: "" })).length;
   return envelope + IV_B64_BYTES + base64Length(plaintext + AES_GCM_TAG_BYTES);
 }
 var MAX_FRAME_BYTES = 42 * 1024 * 1024;
@@ -42022,14 +42230,23 @@ var FetchproxyHelloRejectedError = class extends Error {
   platform;
   /**
    * #418: the remedy, when the reason is one this package knows how to
-   * explain — today only `unsupported-capability`, which blames the browser
-   * rather than the MCP. `null` otherwise.
+   * explain — `unsupported-capability`, which blames the browser rather than
+   * the MCP, and (D12) `awaiting-approval`, which says to approve in the
+   * browser. `null` otherwise.
    */
   hint;
+  /**
+   * D12: `true` only for an `awaiting-approval:` refusal — the extension has
+   * queued an approval card and nobody is at the browser yet, so the same call
+   * succeeds once the person approves. Every other refusal is the extension's
+   * final answer, and retrying unchanged is refused the same way.
+   */
+  retryable;
   constructor(info) {
     const unavailable = parseUnsupportedCapabilityReason(info.reason);
+    const awaiting = parseAwaitingApprovalReason(info.reason);
     const platform = info.platform ?? null;
-    const hint = unavailable !== null ? `${platform ? `this browser (${platform})` : "this browser"} cannot serve any of the capabilities this MCP needs (${unavailable.join(", ")}) \u2014 ContextMint Bridge checked for the browser APIs and they are missing. Nothing is wrong with the MCP or your pairing, and updating will not change it: use this MCP from a browser that provides them (for example Chrome).` : null;
+    const hint = awaiting !== null ? `The extension is waiting for you to approve this MCP` + (awaiting !== "" ? ` (${awaiting})` : "") + ` \u2014 open ContextMint Bridge in your browser, approve it there, then retry. Nothing is wrong with the MCP or your sign-in.` : unavailable !== null ? `${platform ? `this browser (${platform})` : "this browser"} cannot serve any of the capabilities this MCP needs (${unavailable.join(", ")}) \u2014 ContextMint Bridge checked for the browser APIs and they are missing. Nothing is wrong with the MCP or your pairing, and updating will not change it: use this MCP from a browser that provides them (for example Chrome).` : null;
     super(`fetchproxy: the extension refused the connection for "${info.mcpId}": ${info.reason}. ` + (hint !== null ? hint : `This is the extension's own reason \u2014 it is not a timeout, and retrying unchanged will be refused the same way.`));
     this.name = "FetchproxyHelloRejectedError";
     this.mcpId = info.mcpId;
@@ -42037,6 +42254,7 @@ var FetchproxyHelloRejectedError = class extends Error {
     this.unavailableCapabilities = unavailable ?? [];
     this.platform = platform;
     this.hint = hint;
+    this.retryable = awaiting !== null;
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
@@ -42589,7 +42807,7 @@ function originVerdict(origin, allowLocal) {
 }
 var HANDSHAKE_TIMEOUT_MS = 15e3;
 var MAX_PAYLOAD_BYTES = MAX_FRAME_BYTES;
-var enc4 = new TextEncoder();
+var enc5 = new TextEncoder();
 var OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE = 3;
 async function startHost(opts) {
   const allowLocalOrigins = envAllowsLocalOrigins();
@@ -42660,10 +42878,20 @@ async function startHost(opts) {
   let resolveOwnSession;
   let rejectOwnSession;
   let ownSessionReady;
+  let ownRetryableRefusal = false;
+  let ownSessionSettled = false;
   function resetSessionPromise() {
+    ownRetryableRefusal = false;
+    ownSessionSettled = false;
     ownSessionReady = new Promise((resolve7, reject) => {
-      resolveOwnSession = resolve7;
-      rejectOwnSession = reject;
+      resolveOwnSession = (st) => {
+        ownSessionSettled = true;
+        resolve7(st);
+      };
+      rejectOwnSession = (e) => {
+        ownSessionSettled = true;
+        reject(e);
+      };
     });
     ownSessionReady.catch(() => {
     });
@@ -42930,13 +43158,15 @@ async function startHost(opts) {
             const extPub = fromB64(frame.extensionSessionPub);
             const shared = await ecdhX25519(held.priv, extPub);
             const salt = await transcriptHash(held.nonce, extNonce, held.pub, extPub);
-            const key = await hkdfSha256(shared, salt, enc4.encode(HKDF_SESSION_INFO), 32);
+            const key = await hkdfSha256(shared, salt, enc5.encode(HKDF_SESSION_INFO), 32);
             if (extensionWs !== ws)
               return;
             ownSession = new SessionState(key);
             ownSessionInfo = sessionInfoFromHello(verifiedHello);
             ownDecryptFailures = 0;
             ownPendingPairCode = null;
+            if (ownRetryableRefusal)
+              resetSessionPromise();
             resolveOwnSession(ownSession);
           } else {
             const slot = peers.get(frame.mcpId);
@@ -43005,11 +43235,17 @@ async function startHost(opts) {
         }
         if (frame.type === "hello-rejected" && identified === "extension") {
           if (frame.mcpId === opts.ownMcpId) {
-            rejectOwnSession(new FetchproxyHelloRejectedError({
+            const refusal = new FetchproxyHelloRejectedError({
               mcpId: frame.mcpId,
               reason: frame.reason,
               platform: extensionHello?.platform ?? null
-            }));
+            });
+            if (ownRetryableRefusal)
+              resetSessionPromise();
+            const settlesPending = !ownSessionSettled;
+            rejectOwnSession(refusal);
+            if (refusal.retryable && settlesPending)
+              ownRetryableRefusal = true;
           } else {
             const slot = peers.get(frame.mcpId);
             if (slot?.helloFrame.accepts?.includes("hello-rejected")) {
@@ -43125,7 +43361,7 @@ async function startHost(opts) {
 
 // node_modules/@fetchproxy/server/dist/peer.js
 var PEER_DIAL_TIMEOUT_MS = 5e3;
-var enc5 = new TextEncoder();
+var enc6 = new TextEncoder();
 function notSentError() {
   return new Error("fetchproxy: request not sent \u2014 the connection to the bridge host closed before it went out, so nothing reached the browser. It is safe to retry.");
 }
@@ -43225,7 +43461,9 @@ async function startPeer(opts) {
   let rejectFirstReady;
   let sessionPromise;
   let sessionPromiseSettled = false;
+  let retryableRefusal = false;
   function resetSessionPromise() {
+    retryableRefusal = false;
     sessionPromiseSettled = false;
     sessionPromise = new Promise((resolve7, reject) => {
       resolveFirstReady = (st) => {
@@ -43322,6 +43560,8 @@ async function startPeer(opts) {
       raw = JSON.parse(data.toString());
       const frame = validateFrame(raw);
       if (frame.type === "hello" && frame.role === "extension") {
+        if (retryableRefusal)
+          resetSessionPromise();
         extensionHello = frame;
         const mintedKeypair = await generateSessionKeypair();
         const mintedHello = await buildServerHello({
@@ -43351,6 +43591,8 @@ async function startPeer(opts) {
           session = null;
           if (sessionPromiseSettled)
             resetSessionPromise();
+        } else if (retryableRefusal) {
+          resetSessionPromise();
         }
         extensionDisconnectListeners.forEach((cb) => cb());
         return;
@@ -43372,7 +43614,7 @@ async function startPeer(opts) {
         const extNonce = fromB64(authenticated.sessionNonce);
         const shared = await ecdhX25519(held.priv, extPub);
         const salt = await transcriptHash(held.nonce, extNonce, held.pub, extPub);
-        const sessionKey = await hkdfSha256(shared, salt, enc5.encode(HKDF_SESSION_INFO), 32);
+        const sessionKey = await hkdfSha256(shared, salt, enc6.encode(HKDF_SESSION_INFO), 32);
         if (sessionEphemeral !== held) {
           console.warn(`[fetchproxy] ${opts.serverName}: dropping a session derived against an ephemeral that was superseded while it was being derived`);
           return;
@@ -43385,16 +43627,24 @@ async function startPeer(opts) {
         if (isRenegotiation) {
           renegotiateListeners.forEach((cb) => cb());
         } else {
+          if (retryableRefusal)
+            resetSessionPromise();
           resolveFirstReady(session);
         }
         return;
       }
       if (frame.type === "hello-rejected" && frame.mcpId === opts.mcpId) {
-        rejectFirstReady(new FetchproxyHelloRejectedError({
+        const refusal = new FetchproxyHelloRejectedError({
           mcpId: frame.mcpId,
           reason: frame.reason,
           platform: extensionHello?.platform ?? null
-        }));
+        });
+        if (retryableRefusal)
+          resetSessionPromise();
+        const settlesPending = !sessionPromiseSettled;
+        rejectFirstReady(refusal);
+        if (refusal.retryable && settlesPending)
+          retryableRefusal = true;
       }
       if (frame.type === "pair-pending" && frame.mcpId === opts.mcpId) {
         const hello2 = extensionHello;
@@ -43558,8 +43808,9 @@ function classifyFetchError(error62, code2) {
 
 // node_modules/@fetchproxy/server/dist/classify-bridge-error.js
 function classifyBridgeError(err) {
-  if (err instanceof FetchproxyHelloRejectedError)
-    return "hello_rejected";
+  if (err instanceof FetchproxyHelloRejectedError) {
+    return err.retryable ? "awaiting_approval" : "hello_rejected";
+  }
   if (err instanceof FetchproxySessionNotReadyError)
     return "session_not_ready";
   if (err instanceof FetchproxyTimeoutError)
@@ -46330,7 +46581,7 @@ async function loginWithPassword(username, password) {
 // package.json
 var package_default = {
   name: "ofw-mcp",
-  version: "2.20.1",
+  version: "2.20.2",
   license: "MIT",
   mcpName: "io.github.chrischall/ofw-mcp",
   description: "OurFamilyWizard MCP server for Claude \u2014 developed and maintained by AI (Claude Code)",
@@ -46364,14 +46615,14 @@ var package_default = {
     typecheck: "tsc -p tsconfig.json --noEmit"
   },
   dependencies: {
-    "@chrischall/mcp-utils": "^2.13.0",
+    "@chrischall/mcp-utils": "^2.14.0",
     "@fetchproxy/bootstrap": "^3.4.1",
-    "@modelcontextprotocol/server": "^2.2.0",
+    "@modelcontextprotocol/server": "^2.3.0",
     dotenv: "^18.0.0",
     zod: "^4.6.5"
   },
   devDependencies: {
-    "@modelcontextprotocol/client": "^2.2.0",
+    "@modelcontextprotocol/client": "^2.3.0",
     "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^5.0.0",
     esbuild: "^0.28.0",
@@ -46519,10 +46770,10 @@ var OFW_REFRESH_SENTINEL = "ofw";
 async function throwIfEdgeBlocked(response, method, path) {
   if (response.ok) return;
   let edge = detectEdgeBlock({ headers: response.headers, status: response.status });
-  if (edge === null && response.status === 429 && !/json/i.test(response.headers.get("content-type") ?? "")) {
+  if (edge === null && (response.status === 401 || response.status === 429) && !/json/i.test(response.headers.get("content-type") ?? "")) {
     let body = "";
     try {
-      body = await response.clone().text();
+      body = await (response.status === 401 ? response.clone() : response).text();
     } catch {
     }
     edge = detectEdgeBlock({ body, headers: response.headers, status: response.status });
@@ -46585,63 +46836,73 @@ var OFWClient = class {
     return this.tokenManager;
   }
   async request(method, path, body) {
-    const response = await this.fetchAuthed(method, path, body, "application/json");
-    const text = await response.text();
-    if (debugLogEnabled()) {
-      console.error(`[ofw-debug] response body: ${text || "<empty>"}`);
-    }
-    return text ? JSON.parse(text) : null;
+    return this.fetchAuthed(method, path, body, "application/json", async (response) => {
+      const text = await response.text();
+      if (debugLogEnabled()) {
+        console.error(`[ofw-debug] response body: ${text || "<empty>"}`);
+      }
+      return text ? JSON.parse(text) : null;
+    });
   }
   /** Like `request`, but returns the raw bytes plus Content-Type/-Disposition metadata. */
   async requestBinary(method, path) {
-    const response = await this.fetchAuthed(method, path, void 0, "application/octet-stream");
-    return {
+    return this.fetchAuthed(method, path, void 0, "application/octet-stream", async (response) => ({
       body: Buffer.from(await response.arrayBuffer()),
       contentType: response.headers.get("content-type"),
       suggestedFileName: parseContentDispositionFilename(response.headers.get("content-disposition") ?? "") ?? null
-    };
+    }));
   }
   // Authenticated fetch for both JSON and binary callers. Auth (proactive
   // refresh inside the skew window + one 401-replay, guarded against a
   // double-refresh under concurrency) is delegated to the shared TokenManager's
   // `withAuth`. The 429 wait-and-replay and the non-2xx → throw remain here.
-  async fetchAuthed(method, path, body, accept) {
+  async fetchAuthed(method, path, body, accept, consume) {
     let attempt = 0;
-    let response = await this.getTokenManager().withAuth(
-      (token) => this.fetchOnce(method, path, body, accept, token, attempt++ > 0)
-    );
-    await throwIfEdgeBlocked(response, method, path);
+    let result;
+    const call = async (retry) => {
+      let authAttempt = 0;
+      return this.getTokenManager().withAuth((token) => {
+        const firstAuthAttempt = authAttempt++ === 0;
+        return this.fetchOnce(method, path, body, accept, token, async (response2) => {
+          await throwIfEdgeBlocked(response2, method, path);
+          if (response2.status === 401 && firstAuthAttempt) {
+            await releaseBody(response2);
+            return;
+          }
+          if (response2.status === 429) {
+            await releaseBody(response2);
+            return;
+          }
+          if (!response2.ok) {
+            const errorBody = await response2.text();
+            const edge = detectEdgeBlock({ body: errorBody, headers: response2.headers, status: response2.status });
+            if (edge !== null) {
+              throw new EdgeBlockedError(response2.status, edge.vendor, { service: "OurFamilyWizard", method, path });
+            }
+            const safeBody = redactSecrets(errorBody).replace(/\s+/g, " ").trim().slice(0, 4e3);
+            throw new Error(
+              `OFW API error: ${response2.status} ${response2.statusText} for ${method} ${path}` + (safeBody ? ` \u2014 ${safeBody}` : "")
+            );
+          }
+          result = await consume(response2);
+        }, retry || attempt++ > 0);
+      });
+    };
+    const response = await call(false);
     if (response.status === 429) {
-      await releaseBody(response);
       await new Promise((r) => setTimeout(r, 2e3));
-      response = await this.getTokenManager().withAuth(
-        (token) => this.fetchOnce(method, path, body, accept, token, true)
-      );
-      await throwIfEdgeBlocked(response, method, path);
-      if (response.status === 429) {
-        await releaseBody(response);
+      if ((await call(true)).status === 429) {
         throw new Error("Rate limited by OFW API");
       }
     }
-    if (!response.ok) {
-      const errorBody = await response.text();
-      const edge = detectEdgeBlock({ body: errorBody, headers: response.headers, status: response.status });
-      if (edge !== null) {
-        throw new EdgeBlockedError(response.status, edge.vendor, { service: "OurFamilyWizard", method, path });
-      }
-      const safeBody = redactSecrets(errorBody).replace(/\s+/g, " ").trim().slice(0, 4e3);
-      throw new Error(
-        `OFW API error: ${response.status} ${response.statusText} for ${method} ${path}` + (safeBody ? ` \u2014 ${safeBody}` : "")
-      );
-    }
-    return response;
+    return result;
   }
   // A single OFW API fetch with the bearer token supplied by `withAuth`.
   // Carries the per-request timeout (AbortController + setTimeout so vitest
   // fake timers can drive it and we attach a clear error message) and the
-  // OFW_DEBUG_LOG instrumentation. Returns the raw Response — 401/429/non-2xx
-  // handling lives in the callers (`withAuth` and `fetchAuthed`).
-  async fetchOnce(method, path, body, accept, token, isRetry = false) {
+  // OFW_DEBUG_LOG instrumentation. The handler completes body consumption or
+  // release before this attempt returns its Response to `withAuth`.
+  async fetchOnce(method, path, body, accept, token, handleResponse, isRetry = false) {
     const isFormData = body instanceof FormData;
     const headers = {
       ...OFW_PROTOCOL_HEADERS,
@@ -46661,22 +46922,31 @@ var OFWClient = class {
     const ac = new AbortController();
     const timer = setTimeout(() => ac.abort(), timeoutMs);
     const startedAt = Date.now();
-    let response;
+    const signal = withAmbientCancellation(ac.signal);
+    let onAbort;
+    const aborted2 = new Promise((_resolve, reject) => {
+      onAbort = () => reject(signal.reason);
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    });
     try {
-      response = await fetch(url2, {
-        method,
-        headers,
-        // THE CALLER'S CANCELLATION, folded in with our timeout (mcp-utils
-        // `cancel`). Until this the only thing that could stop an OFW
-        // request was the timeout below, so a cancelled tool call held it
-        // open for the full budget while the child burned the CPU
-        // mcp-host meters it on. The timeout diagnosis below is unaffected
-        // because it asks `ac.signal`, OUR controller — a caller's abort
-        // falls through to the generic path rather than being reported as
-        // OFW being slow.
-        signal: withAmbientCancellation(ac.signal),
-        ...body !== void 0 ? { body: isFormData ? body : JSON.stringify(body) } : {}
-      });
+      return await Promise.race([aborted2, (async () => {
+        signal.throwIfAborted();
+        const response = await fetch(url2, {
+          method,
+          headers,
+          // The caller's cancellation and our timeout both cover headers,
+          // body reads and releases; only our controller diagnoses slowness.
+          signal,
+          ...body !== void 0 ? { body: isFormData ? body : JSON.stringify(body) } : {}
+        });
+        if (debugLogEnabled()) {
+          console.error(`[ofw-debug] \u2190 ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
+        }
+        await handleResponse(response);
+        signal.throwIfAborted();
+        return response;
+      })()]);
     } catch (err) {
       const elapsed = Date.now() - startedAt;
       if (ac.signal.aborted) {
@@ -46693,11 +46963,8 @@ var OFWClient = class {
       throw err;
     } finally {
       clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
     }
-    if (debugLogEnabled()) {
-      console.error(`[ofw-debug] \u2190 ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
-    }
-    return response;
   }
 };
 var client = new OFWClient();
@@ -50942,7 +51209,7 @@ function registerCalendarTools(server, client2) {
     });
   });
   if (allowWrites) server.registerTool("ofw_update_event", {
-    description: "Update an existing OurFamilyWizard calendar event. Fetches the event, applies the given changes, and writes the merged result back (OFW has no partial update). A change to an event the co-parent can see (shared before or after the change) is confirmed first; the confirmation is bound to the event exactly as read, so if it changes on OFW in between (say the co-parent edited it) the update is refused instead of overwriting their edit. " + CONFIRM_NOTE,
+    description: "Update an existing OurFamilyWizard calendar event. Fetches the event, applies the given changes, and writes the merged result back (OFW has no partial update). A change to an event the co-parent can see (shared before or after the change) is confirmed first; the confirmation is bound to the event exactly as read, so if it changes on OFW in between (say the co-parent edited it) the update is refused instead of overwriting their edit. If the write fails without a definitive answer, or lands but cannot be re-read to confirm it, the result is EVENT_UNCONFIRMED: the change may already be on OFW, so do NOT retry until ofw_list_events shows whether it landed. " + CONFIRM_NOTE,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       eventId: external_exports.string().describe("Event id \u2014 the `id` from ofw_list_events / eventRecurrenceId from ofw_create_event"),
@@ -50991,13 +51258,30 @@ function registerCalendarTools(server, client2) {
       });
       if (gate) return gate;
     }
-    await client2.request("PUT", `/pub/v3/events/${id}`, payload);
-    const rawAfter = await client2.request("GET", `/pub/v3/events/${id}`);
-    const event = parseLenient(eventDetailSchema, rawAfter, { label: "ofw-mcp", context: `GET /pub/v3/events/${eventId} (post-update)`, mode: "strict" });
-    return jsonResponse({ note: "Event updated; returning re-fetched event state.", event });
+    try {
+      await requestWrite(client2, "PUT", `/pub/v3/events/${id}`, payload);
+    } catch (e) {
+      if (!(e instanceof UnconfirmedWriteError)) throw e;
+      return unconfirmedWriteResponse(e, {
+        result: "EVENT_UNCONFIRMED",
+        what: `update event ${eventId}`,
+        checkWith: "ofw_list_events for this event and date range"
+      });
+    }
+    try {
+      const rawAfter = await client2.request("GET", `/pub/v3/events/${id}`);
+      const event = parseLenient(eventDetailSchema, rawAfter, { label: "ofw-mcp", context: `GET /pub/v3/events/${eventId} (post-update)`, mode: "strict" });
+      return jsonResponse({ note: "Event updated; returning re-fetched event state.", event });
+    } catch (e) {
+      return unconfirmedWriteResponse(new UnconfirmedWriteError(null, e), {
+        result: "EVENT_UNCONFIRMED",
+        what: `verify the update to event ${eventId}`,
+        checkWith: "ofw_list_events for this event and date range"
+      });
+    }
   });
   if (allowWrites) server.registerTool("ofw_delete_event", {
-    description: "Delete an OurFamilyWizard calendar event. Reads the event first; deleting one the co-parent can see is confirmed first, with a preview of exactly which event (title, date, time) is removed, and is refused if the event changed on OFW after that preview. " + CONFIRM_NOTE,
+    description: "Delete an OurFamilyWizard calendar event. Reads the event first; deleting one the co-parent can see is confirmed first, with a preview of exactly which event (title, date, time) is removed, and is refused if the event changed on OFW after that preview. If the request fails without a definitive answer the result is EVENT_UNCONFIRMED: the event may already be gone, so do NOT retry until ofw_list_events shows whether it is still there. " + CONFIRM_NOTE,
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
     inputSchema: external_exports.object({
       eventId: external_exports.string().describe("Event id \u2014 the `id` from ofw_list_events / eventRecurrenceId from ofw_create_event"),
@@ -51030,7 +51314,16 @@ function registerCalendarTools(server, client2) {
       });
       if (gate) return gate;
     }
-    await client2.request("DELETE", `/pub/v3/events/${id}?includeFuture=${includeFuture}`);
+    try {
+      await requestWrite(client2, "DELETE", `/pub/v3/events/${id}?includeFuture=${includeFuture}`);
+    } catch (e) {
+      if (!(e instanceof UnconfirmedWriteError)) throw e;
+      return unconfirmedWriteResponse(e, {
+        result: "EVENT_UNCONFIRMED",
+        what: `delete event ${args.eventId}${includeFuture ? " and its future occurrences" : ""}`,
+        checkWith: "ofw_list_events for this event and date range (including future occurrences if requested)"
+      });
+    }
     return textResponse(`Event ${args.eventId} ("${current.title}") deleted`);
   });
 }
@@ -52206,7 +52499,7 @@ var tools = selectToolRegistrars({
 });
 await runMcp({
   name: "ofw",
-  version: "2.20.1",
+  version: "2.20.2",
   // x-release-please-version
   deps: client,
   tools,
@@ -52214,7 +52507,7 @@ await runMcp({
 });
 /*! Bundled license information:
 
-@modelcontextprotocol/server/dist/src-BHSMhZ_W.mjs:
+@modelcontextprotocol/server/dist/src-Cqbh3MYc.mjs:
   (*!
   * content-type
   * Copyright(c) 2015 Douglas Christopher Wilson