@zuplo/cli 6.73.27 → 6.73.29

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/README.md

@@ -124,19 +124,19 @@ Please note that certain algorithms may not be available depending on the runtim
 <details>
 <summary>Details</summary>
 
-- JSON Web Signature (JWS) - [RFC7515](https://www.rfc-editor.org/rfc/rfc7515)
-- JSON Web Encryption (JWE) - [RFC7516](https://www.rfc-editor.org/rfc/rfc7516)
-- JSON Web Key (JWK) - [RFC7517](https://www.rfc-editor.org/rfc/rfc7517)
-- JSON Web Algorithms (JWA) - [RFC7518](https://www.rfc-editor.org/rfc/rfc7518)
-- JSON Web Token (JWT) - [RFC7519](https://www.rfc-editor.org/rfc/rfc7519)
-- JSON Web Key Thumbprint - [RFC7638](https://www.rfc-editor.org/rfc/rfc7638)
-- JSON Web Key Thumbprint URI - [RFC9278](https://www.rfc-editor.org/rfc/rfc9278)
-- JWS Unencoded Payload Option - [RFC7797](https://www.rfc-editor.org/rfc/rfc7797)
-- CFRG Elliptic Curve ECDH and Signatures - [RFC8037](https://www.rfc-editor.org/rfc/rfc8037)
-- Fully-Specified Algorithms for JOSE - [RFC9864](https://www.rfc-editor.org/rfc/rfc9864.html)
-- ML-DSA for JOSE - [RFC9964](https://www.rfc-editor.org/rfc/rfc9964.html)
-
-The algorithm implementations in `jose` have been tested using test vectors from their respective specifications as well as [RFC7520](https://www.rfc-editor.org/rfc/rfc7520).
+- JSON Web Signature (JWS) - [RFC7515](https://www.rfc-editor.org/info/rfc7515/)
+- JSON Web Encryption (JWE) - [RFC7516](https://www.rfc-editor.org/info/rfc7516/)
+- JSON Web Key (JWK) - [RFC7517](https://www.rfc-editor.org/info/rfc7517/)
+- JSON Web Algorithms (JWA) - [RFC7518](https://www.rfc-editor.org/info/rfc7518/)
+- JSON Web Token (JWT) - [RFC7519](https://www.rfc-editor.org/info/rfc7519/)
+- JSON Web Key Thumbprint - [RFC7638](https://www.rfc-editor.org/info/rfc7638/)
+- JSON Web Key Thumbprint URI - [RFC9278](https://www.rfc-editor.org/info/rfc9278/)
+- JWS Unencoded Payload Option - [RFC7797](https://www.rfc-editor.org/info/rfc7797/)
+- CFRG Elliptic Curve ECDH and Signatures - [RFC8037](https://www.rfc-editor.org/info/rfc8037/)
+- Fully-Specified Algorithms for JOSE - [RFC9864](https://www.rfc-editor.org/info/rfc9864/)
+- ML-DSA for JOSE - [RFC9964](https://www.rfc-editor.org/info/rfc9964/)
+
+The algorithm implementations in `jose` have been tested using test vectors from their respective specifications as well as [RFC7520](https://www.rfc-editor.org/info/rfc7520/).
 
 </details>
 

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/index.d.ts

@@ -27,8 +27,9 @@ export { EncryptJWT } from './jwt/encrypt.js';
 export { calculateJwkThumbprint, calculateJwkThumbprintUri } from './jwk/thumbprint.js';
 export { EmbeddedJWK } from './jwk/embedded.js';
 export { createLocalJWKSet } from './jwks/local.js';
+export type { LocalJWKSet } from './jwks/local.js';
 export { createRemoteJWKSet, jwksCache, customFetch } from './jwks/remote.js';
-export type { RemoteJWKSetOptions, JWKSCacheInput, ExportedJWKSCache, FetchImplementation, } from './jwks/remote.js';
+export type { RemoteJWKSet, RemoteJWKSetOptions, JWKSCacheInput, ExportedJWKSCache, FetchImplementation, } from './jwks/remote.js';
 export { UnsecuredJWT } from './jwt/unsecured.js';
 export type { UnsecuredResult } from './jwt/unsecured.js';
 export { exportPKCS8, exportSPKI, exportJWK } from './key/export.js';
@@ -40,16 +41,16 @@ export type { ProtectedHeaderParameters } from './util/decode_protected_header.j
 import * as errors from './util/errors.js';
 export { errors };
 export { generateKeyPair } from './key/generate_key_pair.js';
-export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/generate_key_pair.js';
+export type { GenerateKeyPairAlgorithm, GenerateKeyPairResult, GenerateKeyPairOptions, } from './key/generate_key_pair.js';
 export { generateSecret } from './key/generate_secret.js';
-export type { GenerateSecretOptions } from './key/generate_secret.js';
+export type { GenerateSecretAlgorithm, GenerateSecretOptions } from './key/generate_secret.js';
 import * as base64url from './util/base64url.js';
 export { base64url };
-export type { CompactDecryptResult, CompactJWEHeaderParameters, CompactJWSHeaderParameters, CompactVerifyResult, CritOption, CryptoKey, DecryptOptions, EncryptOptions, FlattenedDecryptResult, FlattenedJWE, FlattenedJWS, FlattenedJWSInput, FlattenedVerifyResult, GeneralDecryptResult, GeneralJWE, GeneralJWS, GeneralJWSInput, GeneralVerifyResult, GetKeyFunction, JoseHeaderParameters, JSONWebKeySet, JWEHeaderParameters, JWEKeyManagementHeaderParameters, JWK_EC_Private, JWK_EC_Public, JWK_oct, JWK_OKP_Private, JWK_OKP_Public, JWK_RSA_Private, JWK_RSA_Public, JWK, JWKParameters, JWSHeaderParameters, JWTClaimVerificationOptions, JWTDecryptResult, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject, ProduceJWT, ResolvedKey, SignOptions, VerifyOptions, } from './types.d.ts';
+export type { AnyJWK, CompactDecryptResult, CompactJWEHeaderParameters, CompactJWSHeaderParameters, CompactVerifyResult, CritOption, CryptoKey, DecryptOptions, EncryptOptions, FlattenedDecryptResult, FlattenedJWE, FlattenedJWS, FlattenedJWSInput, FlattenedVerifyResult, GeneralDecryptResult, GeneralJWE, GeneralJWS, GeneralJWSInput, GeneralVerifyResult, GetKeyFunction, JoseHeaderParameters, JSONWebKeySet, JWEContentEncryptionAlgorithm, JWEHeaderParameters, JWEKeyManagementAlgorithm, JWEKeyManagementHeaderParameters, JWK_AKP_Private, JWK_AKP_Public, JWK_EC_Private, JWK_EC_Public, JWK_oct, JWK_OKP_Private, JWK_OKP_Public, JWK_RSA_Private, JWK_RSA_Public, JWK, JWKKeyType, JWKParameters, JWSAlgorithm, JWSHeaderParameters, JWTClaimVerificationOptions, JWTDecryptResult, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyInput, KeyObject, ProduceJWT, ResolvedKey, SignOptions, VerifyOptions, } from './types.d.ts';
 /**
  * In prior releases this indicated whether a Node.js-specific build was loaded, this is now fixed
  * to `"WebCryptoAPI"`
  *
- * @deprecated
+ * @deprecated Remove any runtime branching on this value; it is always `"WebCryptoAPI"`.
  */
 export declare const cryptoRuntime = "WebCryptoAPI";

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/compact/decrypt.d.ts

@@ -1,31 +1,37 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in Compact Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
 /**
  * Interface for Compact JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface CompactDecryptGetKey extends types.GetKeyFunction<types.CompactJWEHeaderParameters, types.FlattenedJWE> {
+export interface CompactDecryptGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.CompactJWEHeaderParameters, types.FlattenedJWE, KeyType | types.KeyObject | types.JWK> {
 }
 /**
  * Decrypts a Compact JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/compact/decrypt'`.
- *
  * @param jwe Compact JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function compactDecrypt(jwe: string | Uint8Array, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.CompactDecryptResult>;
+export declare function compactDecrypt(jwe: string | Uint8Array, key: types.KeyInput, options?: types.DecryptOptions): Promise<types.CompactDecryptResult>;
 /**
+ * Decrypts a Compact JWE, resolving the key dynamically. The result additionally carries the
+ * {@link types.ResolvedKey.key resolved key}.
+ *
  * @param jwe Compact JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function compactDecrypt(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: types.DecryptOptions): Promise<types.CompactDecryptResult & types.ResolvedKey>;
+export declare function compactDecrypt<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jwe: string | Uint8Array, getKey: CompactDecryptGetKey<KeyType>, options?: types.DecryptOptions): Promise<types.CompactDecryptResult & types.ResolvedKey<KeyType>>;
+/**
+ * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
+ * either a key or a key resolution function; `key` is present on the result only when a resolution
+ * function was used.
+ *
+ * @param jwe Compact JWE.
+ * @param key Private Key or Secret, or a function resolving one, to decrypt the JWE with. See
+ *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+ * @param options JWE Decryption options.
+ */
+export declare function compactDecrypt(jwe: string | Uint8Array, key: types.KeyInput | CompactDecryptGetKey, options?: types.DecryptOptions): Promise<types.CompactDecryptResult & Partial<types.ResolvedKey>>;

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/compact/encrypt.d.ts

@@ -1,16 +1,5 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in Compact Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
-/**
- * The CompactEncrypt class is used to build and encrypt Compact JWE strings.
- *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/compact/encrypt'`.
- *
- */
+/** The CompactEncrypt class is used to build and encrypt Compact JWE strings. */
 export declare class CompactEncrypt {
     #private;
     /**
@@ -21,7 +10,7 @@ export declare class CompactEncrypt {
     constructor(plaintext: Uint8Array);
     /**
      * Sets a content encryption key to use, by default a random suitable one is generated for the JWE
-     * enc" (Encryption Algorithm) Header Parameter.
+     * "enc" (Encryption Algorithm) Header Parameter.
      *
      * @deprecated You should not use this method. It is only really intended for test and vector
      *   validation purposes.
@@ -31,7 +20,7 @@ export declare class CompactEncrypt {
     setContentEncryptionKey(cek: Uint8Array): this;
     /**
      * Sets the JWE Initialization Vector to use for content encryption, by default a random suitable
-     * one is generated for the JWE enc" (Encryption Algorithm) Header Parameter.
+     * one is generated for the JWE "enc" (Encryption Algorithm) Header Parameter.
      *
      * @deprecated You should not use this method. It is only really intended for test and vector
      *   validation purposes.
@@ -46,10 +35,9 @@ export declare class CompactEncrypt {
      */
     setProtectedHeader(protectedHeader: types.CompactJWEHeaderParameters): this;
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
+     * Sets the JWE Key Management parameters to be used when encrypting. For ECDH based algorithms,
+     * use this method to set the "apu" (Agreement PartyUInfo) or "apv" (Agreement PartyVInfo)
+     * parameters.
      *
      * @param parameters JWE Key Management parameters.
      */
@@ -61,5 +49,5 @@ export declare class CompactEncrypt {
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    encrypt(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.EncryptOptions): Promise<string>;
+    encrypt(key: types.KeyInput, options?: types.EncryptOptions): Promise<string>;
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/flattened/decrypt.d.ts

@@ -1,31 +1,37 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in Flattened JSON Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
 /**
  * Interface for Flattened JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface FlattenedDecryptGetKey extends types.GetKeyFunction<types.JWEHeaderParameters | undefined, types.FlattenedJWE> {
+export interface FlattenedDecryptGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.JWEHeaderParameters | undefined, types.FlattenedJWE, KeyType | types.KeyObject | types.JWK> {
 }
 /**
  * Decrypts a Flattened JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/flattened/decrypt'`.
- *
  * @param jwe Flattened JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function flattenedDecrypt(jwe: types.FlattenedJWE, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult>;
+export declare function flattenedDecrypt(jwe: types.FlattenedJWE, key: types.KeyInput, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult>;
 /**
+ * Decrypts a Flattened JWE, resolving the key dynamically. The result additionally carries the
+ * {@link types.ResolvedKey.key resolved key}.
+ *
  * @param jwe Flattened JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function flattenedDecrypt(jwe: types.FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult & types.ResolvedKey>;
+export declare function flattenedDecrypt<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jwe: types.FlattenedJWE, getKey: FlattenedDecryptGetKey<KeyType>, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult & types.ResolvedKey<KeyType>>;
+/**
+ * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
+ * either a key or a key resolution function; `key` is present on the result only when a resolution
+ * function was used.
+ *
+ * @param jwe Flattened JWE.
+ * @param key Private Key or Secret, or a function resolving one, to decrypt the JWE with. See
+ *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+ * @param options JWE Decryption options.
+ */
+export declare function flattenedDecrypt(jwe: types.FlattenedJWE, key: types.KeyInput | FlattenedDecryptGetKey, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult & Partial<types.ResolvedKey>>;

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/flattened/encrypt.d.ts

@@ -1,16 +1,5 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in Flattened JSON Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
-/**
- * The FlattenedEncrypt class is used to build and encrypt Flattened JWE objects.
- *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/flattened/encrypt'`.
- *
- */
+/** The FlattenedEncrypt class is used to build and encrypt Flattened JWE objects. */
 export declare class FlattenedEncrypt {
     #private;
     /**
@@ -20,10 +9,9 @@ export declare class FlattenedEncrypt {
      */
     constructor(plaintext: Uint8Array);
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
+     * Sets the JWE Key Management parameters to be used when encrypting. For ECDH based algorithms,
+     * use this method to set the "apu" (Agreement PartyUInfo) or "apv" (Agreement PartyVInfo)
+     * parameters.
      *
      * @param parameters JWE Key Management parameters.
      */
@@ -54,7 +42,7 @@ export declare class FlattenedEncrypt {
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
     /**
      * Sets a content encryption key to use, by default a random suitable one is generated for the JWE
-     * enc" (Encryption Algorithm) Header Parameter.
+     * "enc" (Encryption Algorithm) Header Parameter.
      *
      * @deprecated You should not use this method. It is only really intended for test and vector
      *   validation purposes.
@@ -64,7 +52,7 @@ export declare class FlattenedEncrypt {
     setContentEncryptionKey(cek: Uint8Array): this;
     /**
      * Sets the JWE Initialization Vector to use for content encryption, by default a random suitable
-     * one is generated for the JWE enc" (Encryption Algorithm) Header Parameter.
+     * one is generated for the JWE "enc" (Encryption Algorithm) Header Parameter.
      *
      * @deprecated You should not use this method. It is only really intended for test and vector
      *   validation purposes.
@@ -79,5 +67,5 @@ export declare class FlattenedEncrypt {
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    encrypt(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.EncryptOptions): Promise<types.FlattenedJWE>;
+    encrypt(key: types.KeyInput, options?: types.EncryptOptions): Promise<types.FlattenedJWE>;
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/general/decrypt.d.ts

@@ -1,23 +1,14 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in General JSON Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
 /**
  * Interface for General JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface GeneralDecryptGetKey extends types.GetKeyFunction<types.JWEHeaderParameters, types.FlattenedJWE> {
+export interface GeneralDecryptGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.JWEHeaderParameters | undefined, types.FlattenedJWE, KeyType | types.KeyObject | types.JWK> {
 }
 /**
  * Decrypts a General JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/general/decrypt'`.
- *
- * > [!NOTE]\
- * > The function iterates over the `recipients` array in the General JWE and returns the decryption
+ * > Note: The function iterates over the `recipients` array in the General JWE and returns the decryption
  * > result of the first recipient entry that can be successfully decrypted. The result only contains
  * > the plaintext and headers of that successfully decrypted recipient entry. Other recipient entries
  * > in the General JWE are not validated, and their headers are not included in the returned result.
@@ -28,11 +19,25 @@ export interface GeneralDecryptGetKey extends types.GetKeyFunction<types.JWEHead
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function generalDecrypt(jwe: types.GeneralJWE, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult>;
+export declare function generalDecrypt(jwe: types.GeneralJWE, key: types.KeyInput, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult>;
 /**
+ * Decrypts a General JWE, resolving the key dynamically. The result additionally carries the
+ * {@link types.ResolvedKey.key resolved key}.
+ *
  * @param jwe General JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function generalDecrypt(jwe: types.GeneralJWE, getKey: GeneralDecryptGetKey, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult & types.ResolvedKey>;
+export declare function generalDecrypt<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jwe: types.GeneralJWE, getKey: GeneralDecryptGetKey<KeyType>, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult & types.ResolvedKey<KeyType>>;
+/**
+ * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
+ * either a key or a key resolution function; `key` is present on the result only when a resolution
+ * function was used.
+ *
+ * @param jwe General JWE.
+ * @param key Private Key or Secret, or a function resolving one, to decrypt the JWE with. See
+ *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+ * @param options JWE Decryption options.
+ */
+export declare function generalDecrypt(jwe: types.GeneralJWE, key: types.KeyInput | GeneralDecryptGetKey, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult & Partial<types.ResolvedKey>>;

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/general/encrypt.d.ts

@@ -1,8 +1,3 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in General JSON Serialization
- *
- * @module
- */
 import type * as types from '../../types.d.ts';
 /** Used to build General JWE object's individual recipients. */
 export interface Recipient {
@@ -13,28 +8,32 @@ export interface Recipient {
      */
     setUnprotectedHeader(unprotectedHeader: types.JWEHeaderParameters): Recipient;
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
+     * Sets the JWE Key Management parameters to be used when encrypting. For ECDH based algorithms,
+     * use this method to set the "apu" (Agreement PartyUInfo) or "apv" (Agreement PartyVInfo)
+     * parameters.
      *
      * @param parameters JWE Key Management parameters.
      */
     setKeyManagementParameters(parameters: types.JWEKeyManagementHeaderParameters): Recipient;
-    /** A shorthand for calling addRecipient() on the enclosing {@link GeneralEncrypt} instance */
-    addRecipient(...args: Parameters<GeneralEncrypt['addRecipient']>): Recipient;
-    /** A shorthand for calling encrypt() on the enclosing {@link GeneralEncrypt} instance */
-    encrypt(...args: Parameters<GeneralEncrypt['encrypt']>): Promise<types.GeneralJWE>;
+    /**
+     * A shorthand for calling {@link GeneralEncrypt.addRecipient addRecipient()} on the enclosing
+     * {@link GeneralEncrypt} instance.
+     *
+     * @param key Public Key or Secret to encrypt the Content Encryption Key for the recipient with.
+     *   See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+     * @param options JWE Encryption options.
+     */
+    addRecipient(key: types.KeyInput, options?: types.CritOption): Recipient;
+    /**
+     * A shorthand for calling {@link GeneralEncrypt.encrypt encrypt()} on the enclosing
+     * {@link GeneralEncrypt} instance. Takes no arguments — each recipient's key is supplied to
+     * {@link addRecipient}.
+     */
+    encrypt(): Promise<types.GeneralJWE>;
     /** Returns the enclosing {@link GeneralEncrypt} instance */
     done(): GeneralEncrypt;
 }
-/**
- * The GeneralEncrypt class is used to build and encrypt General JWE objects.
- *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/general/encrypt'`.
- *
- */
+/** The GeneralEncrypt class is used to build and encrypt General JWE objects. */
 export declare class GeneralEncrypt {
     #private;
     /**
@@ -50,7 +49,7 @@ export declare class GeneralEncrypt {
      *   See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    addRecipient(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.CritOption): Recipient;
+    addRecipient(key: types.KeyInput, options?: types.CritOption): Recipient;
     /**
      * Sets the JWE Protected Header on the GeneralEncrypt object.
      *

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwk/embedded.d.ts

@@ -1,17 +1,13 @@
-/**
- * Verification using a JWK Embedded in a JWS Header
- *
- * @module
- */
 import type * as types from '../types.d.ts';
 /**
- * EmbeddedJWK is an implementation of a GetKeyFunction intended to be used with the JWS/JWT verify
- * operations whenever you need to opt-in to verify signatures with a public key embedded in the
- * token's "jwk" (JSON Web Key) Header Parameter. It is recommended to combine this with the verify
- * function's `algorithms` option to define accepted JWS "alg" (Algorithm) Header Parameter values.
- *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/embedded'`.
+ * EmbeddedJWK is an implementation of a {@link types.GetKeyFunction GetKeyFunction} intended to be
+ * used with the JWS/JWT verify operations whenever you need to opt-in to verify signatures with a
+ * public key embedded in the token's "jwk" (JSON Web Key) Header Parameter. It is recommended to
+ * combine this with the verify function's `algorithms` option to define accepted JWS "alg"
+ * (Algorithm) Header Parameter values.
  *
+ * @param protectedHeader JWS Protected Header.
+ * @param token The consumed JWS token.
+ * @returns The public key from the JWS "jwk" (JSON Web Key) Header Parameter.
  */
 export declare function EmbeddedJWK(protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput): Promise<types.CryptoKey>;

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwk/thumbprint.d.ts

@@ -1,32 +1,17 @@
-/**
- * JSON Web Key Thumbprint and JSON Web Key Thumbprint URI
- *
- * @module
- */
 import type * as types from '../types.d.ts';
 /**
  * Calculates a base64url-encoded JSON Web Key (JWK) Thumbprint
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/thumbprint'`.
- *
  * @param key Key to calculate the thumbprint for.
  * @param digestAlgorithm Digest Algorithm to use for calculating the thumbprint. Default is
  *   "sha256".
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc7638 RFC7638}
  */
 export declare function calculateJwkThumbprint(key: types.JWK | types.CryptoKey | types.KeyObject, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
 /**
  * Calculates a JSON Web Key (JWK) Thumbprint URI
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/thumbprint'`.
- *
  * @param key Key to calculate the thumbprint for.
  * @param digestAlgorithm Digest Algorithm to use for calculating the thumbprint. Default is
  *   "sha256".
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc9278 RFC9278}
  */
 export declare function calculateJwkThumbprintUri(key: types.CryptoKey | types.KeyObject | types.JWK, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwks/local.d.ts

@@ -1,29 +1,20 @@
-/**
- * Verification using a JSON Web Key Set (JWKS) available locally
- *
- * @module
- */
 import type * as types from '../types.d.ts';
+/** The key resolution function returned by {@link createLocalJWKSet}. */
+export interface LocalJWKSet {
+    (protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput): Promise<types.CryptoKey>;
+    /** Returns a structured clone of the JSON Web Key Set this resolver was created with. */
+    jwks: () => types.JSONWebKeySet;
+}
 /**
  * Returns a function that resolves a JWS JOSE Header to a public key object from a locally stored,
- * or otherwise available, JSON Web Key Set.
+ * or otherwise available, JSON Web Key Set. Selection respects the header's "alg" (Algorithm) and
+ * "kid" (Key ID) as well as the JWK's "use" (Public Key Use) and "key_ops" (Key Operations).
+ * Exactly one key must match; if multiple keys match, the thrown `JWKSMultipleMatchingKeys` can be
+ * iterated.
  *
- * It uses the "alg" (JWS Algorithm) Header Parameter to determine the right JWK "kty" (Key Type),
- * then proceeds to match the JWK "kid" (Key ID) with one found in the JWS Header Parameters (if
- * there is one) while also respecting the JWK "use" (Public Key Use) and JWK "key_ops" (Key
- * Operations) Parameters (if they are present on the JWK).
- *
- * Only a single public key must match the selection process. As shown in the example below when
- * multiple keys get matched it is possible to opt-in to iterate over the matched keys and attempt
- * verification in an iterative manner.
- *
- * > [!NOTE]\
- * > The function's purpose is to resolve public keys used for verifying signatures and will not work
+ * > Note: The function's purpose is to resolve public keys used for verifying signatures and will not work
  * > for public encryption keys.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwks/local'`.
- *
  * @param jwks JSON Web Key Set formatted object.
  */
-export declare function createLocalJWKSet(jwks: types.JSONWebKeySet): (protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput) => Promise<types.CryptoKey>;
+export declare function createLocalJWKSet(jwks: types.JSONWebKeySet): LocalJWKSet;