Method, device, equipment and product for generating deployment information of plug-in

Abstract

The invention relates to a method, a device, equipment and a product for generating deployment information of a plug-in used in an application. The method includes obtaining a description of the plug-in, the description being written in a natural language and including information for deploying the plug-in. The method further includes generating deployment information for the plug-in using a language model based on the description. In addition, the method further comprises the step of sending deployment information to the client, and the deployment information is used for generating an installation script of the plug-in. In this way, the server can utilize the language model to automatically generate the deployment information of the plug-in, so that the time of a user for deploying the plug-in can be shortened, the requirement for professional knowledge of the user is lowered, and the success rate of plug-in deployment is increased.

Description

Technical Field

[0001] The present disclosure relates to the field of software automation, and more particularly to a method, apparatus, device, and product for generating deployment information of a plug-in used in an application. Background Art

[0002] More and more application platforms are beginning to support the integration of third-party services through plug-in mechanisms to extend the functionality of the application platform. For example, in integrated development environment (IDE) applications, plug-ins in the VSIX file format are widely used. This plug-in has a standardized packaging format and a complete lifecycle management mechanism. VSIX plug-ins are packaged in a unified structure and contain clear metadata and resource files. This standardized structure supports the automated deployment of such traditional plug-ins through the application's built-in extension manager or command-line tools. Throughout the deployment process, the plug-in's version dependencies, resource registration, and feature activation are centrally managed by the IDE framework, eliminating the need for users to manually configure the environment or adjust dependencies. Summary of the Invention

[0003] In a first aspect of an embodiment of the present disclosure, a method for generating deployment information for a plug-in used in an application is provided. The method includes obtaining a description of the plug-in, where the description is written in a natural language and includes information for deploying the plug-in. The method also includes generating the deployment information for the plug-in using a language model based on the description. The method also includes sending the deployment information to a client, where the deployment information is used to generate an installation script for the plug-in.

[0004] In a second aspect of an embodiment of the present disclosure, a method for deploying a plug-in in an application is provided. The method includes, in response to detecting a user interaction indicating deployment of the plug-in in the application, sending a request to a server to obtain deployment information for the plug-in. The method also includes receiving the deployment information from the server, the deployment information being generated based on a description of the plug-in and utilizing a language model, wherein the description is written in a natural language. The method also includes generating an installation script for the application's runtime environment based on the deployment information. The method also includes deploying the plug-in in the application by executing the installation script.

[0005] In a third aspect of an embodiment of the present disclosure, a device for generating deployment information for a plug-in used in an application is provided. The device includes a plug-in description acquisition module configured to acquire a description of the plug-in, where the description is written in a natural language and includes information for deploying the plug-in. The device also includes a deployment information generation module configured to generate deployment information for the plug-in based on the description using a language model. Furthermore, the device also includes a deployment information sending module configured to send the deployment information to a client, where the deployment information is used to generate an installation script for the plug-in.

[0006] In a fourth aspect of an embodiment of the present disclosure, a device for deploying a plug-in in an application is provided. The device includes a deployment request sending module, which is configured to send a request to a server to obtain deployment information of the plug-in in response to detecting a user interaction indicating the deployment of the plug-in in the application. The device also includes a deployment information receiving module, which is configured to receive deployment information from the server, the deployment information being generated based on a description of the plug-in and using a language model, and the description being written in a natural language. The device also includes an installation script generating module, which is configured to generate an installation script for the operating environment of the application based on the deployment information. The device also includes a plug-in deployment module, which is configured to deploy the plug-in into the application by running the installation script.

[0007] In a fifth aspect of an embodiment of the present disclosure, an electronic device is provided. The electronic device includes one or more processors; and a storage device for storing one or more programs, which, when executed by the one or more processors, enables the one or more processors to implement a method for generating deployment information of a plug-in used in an application. The method includes obtaining a description of the plug-in, which is written in a natural language and includes information for deploying the plug-in. The method also includes generating deployment information of the plug-in using a language model based on the description. In addition, the method also includes sending the deployment information to the client, and the deployment information is used to generate an installation script for the plug-in.

[0008] In a sixth aspect of an embodiment of the present disclosure, an electronic device is provided. The electronic device includes one or more processors; and a storage device for storing one or more programs, which, when executed by the one or more processors, causes the one or more processors to implement a method for deploying a plug-in in an application. The method includes, in response to detecting a user interaction indicating deployment of a plug-in in an application, sending a request to a server to obtain deployment information of the plug-in. The method also includes receiving deployment information from the server, the deployment information being generated based on a description of the plug-in and using a language model, and the description being written in a natural language. The method also includes generating an installation script for the operating environment of the application based on the deployment information. The method also includes deploying the plug-in into the application by running the installation script.

[0009] In a seventh aspect of an embodiment of the present disclosure, a computer program product is provided. The computer program product is tangibly stored on a non-transitory computer-readable medium and includes machine-executable instructions that, when executed, cause a machine to implement a method for generating deployment information for a plug-in used in an application. The method includes obtaining a description of the plug-in, the description being written in a natural language and including information for deploying the plug-in. The method also includes generating the deployment information for the plug-in using a language model based on the description. In addition, the method also includes sending the deployment information to a client, where the deployment information is used to generate an installation script for the plug-in.

[0010] In an eighth aspect of an embodiment of the present disclosure, a computer program product is provided. The computer program product is tangibly stored on a non-transitory computer-readable medium and includes machine-executable instructions that, when executed, cause a machine to implement a method for deploying a plug-in in an application. The method includes, in response to detecting a user interaction indicating deployment of the plug-in in the application, sending a request to a server to obtain deployment information of the plug-in. The method also includes receiving deployment information from the server, the deployment information being generated based on a description of the plug-in and using a language model, and the description being written in a natural language. The method also includes generating an installation script for an operating environment of the application based on the deployment information. The method also includes deploying the plug-in into the application by running the installation script.

[0011] This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. It is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. In the accompanying drawings, the same or similar reference numerals represent the same or similar elements, wherein:

[0013] Figure 1 A schematic diagram illustrating an example environment in which various embodiments of the present disclosure may be implemented;

[0014] Figure 2 A flowchart illustrating a method for generating deployment information of a plug-in used in an application according to some embodiments of the present disclosure is shown;

[0015] Figure 3 A flowchart of a method for deploying a plug-in in an application according to some embodiments of the present disclosure is shown;

[0016] Figure 4A flowchart illustrating an example process of deploying a plug-in in an application according to some embodiments of the present disclosure is shown;

[0017] Figure 5 A schematic diagram showing an example of using a large language model to generate deployment information of a plug-in according to some embodiments of the present disclosure;

[0018] Figure 6 A flowchart illustrating an example process of deploying a plug-in at a client according to some embodiments of the present disclosure is shown;

[0019] Figure 7 A schematic diagram illustrating an example of automatically deploying a plug-in from a plug-in market in an application according to some embodiments of the present disclosure;

[0020] Figure 8 A schematic diagram illustrating an example of a user inputting additional configuration information during a plug-in deployment process according to some embodiments of the present disclosure;

[0021] Figure 9 A block diagram illustrating an apparatus for generating deployment information of a plug-in used in an application according to some embodiments of the present disclosure is shown;

[0022] Figure 10 A block diagram of an apparatus for generating a plug-in for deployment in an application according to some embodiments of the present disclosure is shown;

[0023] Figure 11 A block diagram of a device capable of implementing various embodiments of the present disclosure is shown. DETAILED DESCRIPTION

[0024] It is understood that all user-related data involved in this technical solution must be obtained and used only after authorization by the user. This means that if a user's personal information is to be used in this technical solution, the user's explicit consent and authorization must be obtained before such data is obtained; otherwise, the relevant data will not be collected or used. It is also understood that when implementing this technical solution, relevant laws and regulations must be strictly observed during the data collection, use, and storage process, and necessary technologies and measures must be implemented to protect the user's data security and ensure the safe use of data.

[0025] The following describes embodiments of the present disclosure in more detail with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as limited to the embodiments described herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of protection of the present disclosure.

[0026] In the description of the embodiments of the present disclosure, the term "including" and similar terms should be understood as open inclusion, that is, "including but not limited to". The term "based on" should be understood as "based at least in part on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The terms "first", "second", etc. can refer to different or the same objects, unless explicitly stated. Other explicit and implicit definitions may also be included below.

[0027] As mentioned above, some application platforms can support third-party services by installing plug-ins, thereby expanding the functionality of the application platform. For example, in an IDE application, a developer can install a plug-in for a specific database to access that database. In another example, in a design application, a designer can install a plug-in for a specific resource library to import materials from that library into the design application. In another example, in a social networking application, a user can install a plug-in for a specific document editing software to insert articles created using that software into the social networking application.

[0028] When installing plug-ins in these applications, some traditional plug-ins have standardized deployment information, which enables the application to identify the installation file of the plug-in and automatically deploy the plug-in to the application. However, the deployment information of some new plug-ins does not have a unified data structure. The deployment information of these plug-ins may exist in the description of the plug-in (for example, a readme document or other document) in an unstructured form. In the process of deploying such plug-ins, the user needs to read the description of the plug-in and manually configure the environment and install the plug-in according to the description, which makes the deployment process of the plug-in very complicated, thereby reducing the user's success rate in deploying the plug-in and reducing the user's experience in the application.

[0029] Taking IDE applications as an example, traditional IDE plugins are in the VSIX format. Developers can automatically install IDE plugins after downloading them. In recent years, with the development of AI-based IDEs, Model Context Protocol (MCP) plugins have become increasingly common. MCP is a protocol designed for large language models to call external tools or data sources. MCP plugins are server-side components that use MCP to encapsulate and expose services. Most MCP plugins are distributed across various code repositories, where their readme documents and source code are stored. MCP plugin deployment information is typically stored in an unstructured form within the readme document, written in natural language, or other documents within the code repository. Deploying an MCP plugin requires users to read the readme document and, based on the document's contents, copy various commands, configure environment variables, and adjust dependencies. This complicates the deployment process and reduces the success rate of MCP plugin deployment.

[0030] To this end, an embodiment of the present disclosure provides a solution for deploying plug-ins in applications. In this solution, a server can obtain a description of the plug-in, which is written in a natural language and includes information for deploying the plug-in. The server can then use a language model to generate deployment information for the plug-in based on the description. After detecting a user request instructing to deploy the plug-in in the application, the client can send a request to the server to obtain deployment information for the plug-in. The server can then send the generated deployment information to the client. After receiving the deployment information from the server, the client can generate an installation script for the application's operating environment based on the deployment information. The client can then deploy the plug-in into the application by running the installation script.

[0031] In this way, the server can use the language model to automatically generate plugin deployment information, thereby reducing the time users spend deploying plugins, lowering the need for user expertise, and improving the success rate of plugin deployment. Furthermore, compared to directly generating plugin deployment system commands from the language model, using the language model to generate deployment information and then generating an installation script based on this information improves deployment accuracy and success rates. It also enhances environmental security control capabilities, preventing system commands generated by the language model from damaging the system environment.

[0032] Figure 1 1 shows a schematic diagram of an example environment 100 in which various embodiments of the present disclosure may be implemented. Figure 1 As shown, environment 100 includes a server 102, a client 104, and a code repository 106. Server 102 can be any device with processing power or computing power. For example, server 102 can be a cloud server, a local server, a virtual server, a desktop computer, or a laptop computer. Client 104 can be a user device of user 108. For example, client 104 can be a desktop computer, a laptop computer, a tablet computer, a smart phone, a personal assistant, or a smart wearable device. Code repository 106 can be a platform, database, or storage device for storing project code for various projects. For example, code repository 106 can be a developer platform (e.g., GITHUB, etc.).

[0033] In the environment 100, the server 102 can obtain the description 116 and source code of the plug-in 114 from the code repository 106. A developer can develop a plug-in 114 for providing third-party services and write a description 116 of the plug-in 114. The description 116 is written by the developer using a natural language, and its content may include an introduction to the functionality of the plug-in 114 and information for deploying the plug-in 114. This information may include, for example, installation steps, dependencies required to run the plug-in 114, a command to install the plug-in 114, or associated configuration information. The description 116 may be, for example, a readme document (i.e., a README document), other documents, or other forms of text. The developer can store the description 116 and source code of the plug-in 114 in the code repository 106 so that other users of the code repository 106 can view and download the description 116 and source code of the plug-in 114.

[0034] In the environment 100, a language model 110 may be deployed on a server 102. The language model 110 may be, for example, a large language model (LLM) or a language model trained for a specific domain (e.g., a reduced-scale large language model). The server 102 may use the language model 110 to generate deployment information for a plug-in 114 based on the description 116. For example, the deployment information may include the installation steps, dependencies, run commands, or configuration information described above. In addition, the deployment information may also include, for example, the functions supported by the plug-in 114, the programming language of the plug-in 114, or the tag or category of the plug-in 114.

[0035] In environment 100, application 118 may be running on client 104. Application 118 may be any application that supports third-party services by installing plug-ins within the application. For example, application 118 may be an AI-based IDE, a visual design platform, a content publishing platform, etc. A list of deployable plug-ins may be displayed within application 118, and the list of plug-ins may include plug-in 114. User 108 may request the deployment of plug-in 114 within application 118 by interacting with a control associated with plug-in 114.

[0036] In the environment 100, upon detecting a user interaction indicating deployment of a plug-in 114 in an application 118, the client 104 may send a request 122 to the server 102 to obtain deployment information 112 of the plug-in 114. After receiving the request 122, the server 102 may send the deployment information 112 to the client 104. In some embodiments, to facilitate subsequent processing, the deployment information 112 may be standardized into plug-in metadata in a unified format. The server 102 may then send the plug-in metadata to the client 104.

[0037] In the environment 100, after receiving the deployment information 112 of the plug-in 114 from the server 102, the client 104 can generate an installation script 120 for the operating environment of the application 118 (e.g., the system environment of the client 104) based on the deployment information 112. The installation script 120 can be configured with, for example, system configuration commands, installation commands, or execution commands for the plug-in 114. The client 104 can then automatically deploy the plug-in 114 to the application 118 by running the installation script 120. After the deployment is complete, the user 108 can use the functions of the plug-in 114 in the application 118.

[0038] In this manner, server 102 can utilize language model 110 to automatically generate deployment information 112 for plug-in 114, thereby reducing the time required by user 108 to deploy plug-in 114, lowering the expertise required of user 108, and improving the success rate of plug-in 114 deployment. Furthermore, compared to directly generating system commands for deploying plug-in 114 using a language model, generating deployment information 112 using language model 110 and then generating installation script 120 based on deployment information 112 can improve deployment accuracy and success rate, and also enhance environmental security control capabilities, preventing system commands generated by the language model from damaging the system environment.

[0039] Figure 2 1 shows a flow chart of a method 200 for generating deployment information of a plug-in used in an application according to some embodiments of the present disclosure. The method 200 may be executed by a server. For example, the method 200 may be executed by Figure 1 The server 102 executes. Figure 2 As shown, in block 202, the server may obtain a description of the plug-in, which is written in a natural language and includes information for deploying the plug-in. Figure 1 In the illustrated environment 100, the server 102 can obtain a description 116 and source code of a plug-in 114 from the code repository 106. The description 116 is written by a developer using a natural language and may include an introduction to the functionality of the plug-in 114 and information for deploying the plug-in 114. This information may include, for example, installation steps, dependencies required to run the plug-in 114, commands for installing the plug-in 114, or associated configuration information.

[0040] In block 204, the server may generate deployment information for the plug-in based on the description using the language model. Figure 1In the illustrated environment 100, a language model 110 may be deployed on a server 102. Based on a description 116, the server 102 may utilize the language model 110 to generate deployment information for a plug-in 114. For example, the deployment information may include the installation steps, dependencies, runtime commands, or configuration information described above. Furthermore, the deployment information may include, for example, the functions supported by the plug-in 114, the programming language of the plug-in 114, or a tag or category of the plug-in 114.

[0041] In block 206, the server may send deployment information to the client, which is used to generate an installation script for the plug-in. Figure 1 In the illustrated environment 100, upon detecting a user interaction indicating deployment of a plug-in 114 in an application 118, the client 104 may send a request 122 to the server 102 to obtain deployment information 112 for the plug-in 114. After receiving the request 122, the server 102 may send the deployment information 112 to the client 104. The client 104 may generate an installation script 120 for the plug-in 114 based on the deployment information 112, and use the installation script 120 to deploy the plug-in 114 in the application 118.

[0042] Figure 3 1 shows a flow chart of a method 300 for deploying a plug-in in an application according to some embodiments of the present disclosure. The method 300 may be executed by a client. For example, the method 300 may be executed by Figure 1 The client 104 executes. Figure 3 As shown, in block 302, in response to detecting a user interaction indicating deployment of a plug-in in an application, the client may send a request to the server to obtain deployment information of the plug-in. Figure 1 In the illustrated environment 100, an application 118 may be running on a client 104. A list of deployable plug-ins may be displayed in the application 118, and the list of plug-ins may include a plug-in 114. A user 108 may request that the plug-in 114 be deployed in the application 118 by interacting with a control associated with the plug-in 114. Upon detecting a user interaction instructing to deploy the plug-in 114 in the application 118, the client 104 may send a request 122 to the server 102 to obtain deployment information 112 of the plug-in 114.

[0043] In block 304, the client may receive deployment information from the server, the deployment information being generated based on the description of the plug-in and utilizing the language model, and the description being written in a natural language. Figure 1 In the illustrated environment 100 , the client 104 may receive deployment information 112 of a plug-in 114 from the server 102 , wherein the deployment information 112 is generated by the server 102 based on a description 116 written in a natural language and utilizing a language model 110 .

[0044] In block 306, the client may generate an installation script for the application's runtime environment based on the deployment information. Figure 1 In the illustrated environment 100, after receiving deployment information 112 of a plug-in 114 from a server 102, the client 104 may generate an installation script 120 for the runtime environment of the application 118 based on the deployment information 112. The installation script 120 may include, for example, system configuration commands, installation commands, or runtime commands for the plug-in 114.

[0045] In block 308, the client can deploy the plug-in into the application by running the installation script. Figure 1 In the illustrated environment 100 , the client 104 can automatically deploy the plug-in 114 to the application 118 by running the installation script 120 . After the deployment is complete, the user 108 can use the functionality of the plug-in 114 in the application 118 .

[0046] In this way, the server can use the language model to automatically generate plugin deployment information, thereby reducing the time users spend deploying plugins, lowering the need for user expertise, and improving the success rate of plugin deployment. Furthermore, compared to directly generating plugin deployment system commands from the language model, using the language model to generate deployment information and then generating an installation script based on this information improves deployment accuracy and success rates. It also enhances environmental security control capabilities, preventing system commands generated by the language model from damaging the system environment.

[0047] In some embodiments, when sending deployment information to the client, the server can standardize the deployment information into plug-in metadata in a unified format. The server can then send the plug-in metadata to the client. By standardizing the deployment information into plug-in metadata in a unified format and sending the metadata to the client, the structuring and automation capabilities of the plug-in deployment process can be significantly improved. Metadata in a unified format helps the client to quickly parse and adapt the compatibility of information such as the plug-in's dependencies, configuration parameters, and run commands, reducing its reliance on unstructured documents. In addition, the mechanism supports multiple applications to receive and process plug-in deployment information in a consistent manner, thereby enhancing the versatility and scalability of the system. In addition, standardized processing also provides basic support for subsequent security verification, version management, and conflict detection functions, thereby improving the reliability of plug-in deployment and user experience.

[0048] In some embodiments, once the deployment information is generated, the server can add the plug-in to the list of deployable plug-ins. The server can then send a list of deployable plug-ins to the client for display in the application. By adding the plug-in to the list of deployable plug-ins after the deployment information is generated, and sending the list to the client for interface display, centralized management and dynamic updates of plug-in resources can be achieved, improving the system's usability and user interaction experience. The client does not need to parse various plug-in sources by itself, and can uniformly obtain the current set of deployable plug-ins, which is convenient for users to browse, filter and install intuitively with one click. This mechanism can not only simplify the discovery and selection process of plug-ins and reduce the complexity of user operations, but also provide basic support for the system to implement plug-in status management, version control, and classified display functions, thereby further enhancing the scalability and ecological vitality of the platform.

[0049] In some embodiments, the deployment information is standardized into plug-in metadata in a unified format, and the client can generate an installation script based on the plug-in metadata. In some embodiments, the client can obtain environmental information associated with the operating environment of the application. Then, the client can generate an installation script based on the environmental information and the plug-in metadata. By combining the client's ability to identify the application's operating environment, the client can automatically generate a highly adaptable installation script based on the plug-in metadata and environmental information, thereby achieving a flexible plug-in deployment solution. This mechanism can not only reduce deployment failures caused by differences in system environments and improve the accuracy and success rate of the installation process, but also lower the user's cognitive threshold for system configuration details, and improve the degree of automation and cross-platform compatibility of plug-in deployment.

[0050] Figure 4 FIG. 4 is a flow chart illustrating an example process 400 for deploying a plug-in in an application according to some embodiments of the present disclosure. Figure 4 As shown, in block 402, the server may obtain a list of plug-ins to be downloaded. Taking the deployment of an MCP plug-in in an IDE application as an example, the plug-in list may include multiple MCP plug-ins and corresponding download addresses, which can be used to obtain descriptions and source codes of the MCP plug-ins from a code repository.

[0051] In block 404, the server may obtain descriptions of the plug-ins in the plug-in list from the code repository. For example, the server may download a readme document, source code, and related documents of the MCP plug-in from the code repository.

[0052] At block 406, the server may utilize the large language model to generate deployment information based on the plugin description. For example, the server may generate a prompt for the large language model, which may cause the large language model to generate deployment information for the plugin based on the MCP plugin's readme document. The prompt may specify elements required for the deployment information, such as installation steps, dependencies, run commands, or configuration information. The large language model may then generate this deployment information by reading the MCP plugin's readme document.

[0053] At block 408, the server may standardize the deployment information into plugin metadata in a unified format. For example, the server may enter the installation steps, dependencies, runtime commands, and configuration information generated by the large language model into a predefined metadata template to generate plugin metadata. The generated plugin metadata may be, for example, a JSON-formatted code that includes fields corresponding to the deployment information.

[0054] At block 410, the server can publish the plug-in to the plug-in marketplace. For example, after generating the plug-in metadata, the server can add the MCP plug-in's information to a list of deployable plug-ins. When a user opens the MCP plug-in marketplace page in an IDE, the client can retrieve the plug-in list, allowing the user to deploy the MCP plug-in in the list to the IDE with one click, eliminating the need for manual deployment.

[0055] At block 412, the client may detect a user interaction in the application that indicates the deployment of a plugin. For example, a user may click a button in the IDE that deploys a specified MCP plugin with one click. After the client detects the user interaction of clicking the button, it may retrieve plugin metadata for the MCP plugin from the server.

[0056] In block 414 , the client may obtain environment information associated with the IDE operating environment, such as the type of operating system, the version of the operating system, or the version of the installed programming tool.

[0057] At block 416, the client may generate an installation script based on the plugin metadata and environment information. For example, the plugin metadata of an MCP plugin may include configuration information for a first operating system and configuration information for a second operating system. If the user's IDE runs on the first operating system, the client may generate an installation script based on the configuration information for the first operating system. If the user's IDE runs on the second operating system, the client may generate an installation script based on the configuration information for the second operating system. Thus, the generated installation script is specific to the specified MCP plugin and application's operating environment.

[0058] At block 418, the client may deploy the plug-in using the installation script. For example, the client may deploy the specified MCP plug-in in the application by running the installation script generated at block 416. After the deployment is complete, the user may use the deployed MCP plug-in in the IDE.

[0059] In some embodiments, when a language model is used to generate deployment information for a plug-in based on a description of the plug-in, the server can use the language model to generate, based on the description, the installation steps for the plug-in, the dependencies on which the plug-in depends, the run command for installing the plug-in, and configuration information associated with the plug-in. The installation steps can indicate the steps performed during the installation of the plug-in and the order in which these steps are executed. The dependencies can ensure that the deployment environment has the operating conditions required by the plug-in. The installation command can directly drive the actual installation behavior. The configuration information can enable the plug-in to start normally. By generating installation steps, dependencies, installation commands, and configuration information, a comprehensive description and precise control of the plug-in deployment process can be achieved, thereby improving the integrity and automation level of the deployment process.

[0060] In some embodiments, the server may determine that the generation of target information based on the description has failed, and the target information includes any one of installation steps, dependencies, run commands, or configuration information. The server may then obtain the source code of the plug-in, and based on the source code, use a language model to generate the target information. In this way, the robustness and fault tolerance of the deployment information generation process can be improved. This solution can reduce deployment failures caused by missing, non-standard or ambiguous deployment information, so that the system still has the ability to generate accurate deployment information when faced with a plug-in description with incomplete information. By introducing source code as a source of supplementary information, the language model's understanding of the configuration and dependencies of the plug-in can be improved, thereby enhancing the accuracy and reliability of deployment information generation, and further improving the integrity of the plug-in automatic deployment process.

[0061] In some embodiments, the server can generate at least one of the following based on the description using a language model: tool information describing the functionality of the plug-in, the plug-in's programming language, or the plug-in's category. In this way, the client can present richer and more comprehensive plug-in information in the user interface based on the tool information, programming language, or plug-in category, thereby helping users understand the capabilities provided by the plug-in and improving the user experience.

[0062] Figure 5 FIG. 5 is a schematic diagram showing an example 500 of using a large language model to generate deployment information of a plug-in according to some embodiments of the present disclosure. Figure 5As shown, the server can obtain a description of the plug-in 502. For example, the server can download a readme document of the plug-in from a code repository, and the readme document includes a description of the plug-in. The server can then input the description 502 into a large language model 506 (e.g., Figure 1 The language model 110 in the description 502 is shown in FIG. 5 . The large language model 506 can generate the plug-in's installation steps 508, dependencies 510, run commands 512, configuration information 514, tool information 516, programming languages ​​518, and categories 520 based on the description 502. The installation steps 508 refer to a series of operations that need to be performed in sequence to deploy the plug-in. For example, the installation steps 508 may include operations such as cloning project code, installing dependencies, configuring environment variables, and executing run commands. Dependencies 510 refer to software packages, libraries, services, or runtime environments that the plug-in depends on at runtime. For example, dependencies 510 may include programming language dependencies (e.g., libraries), or system dependencies (e.g., system tools such as Node.js and Java), external service dependencies (e.g., databases, external interfaces, etc.), etc. The run command 512 refers to a specific command used to install or run the plug-in. The configuration information 514 may include configuration parameters such as environment variables. The tool information 516 refers to the various functions provided by the plug-in. The programming language 518 refers to the programming language of the plug-in. Category 520 refers to various labels or classification information associated with a plug-in.

[0063] In example 500, installation steps 508, dependencies 510, run commands 512, and configuration information 514 are information used to improve the success rate of the plug-in deployment process, while tool information 516, programming language 518, and category 520 are information used to help users better understand the functions of the plug-in. Therefore, when it is determined that any one of installation steps 508, dependencies 510, run commands 512, and configuration information 514 (e.g., dependency 510) is missing from the deployment information generated by large language model 506 based on description 502, the server can obtain the source code 504 of the plug-in. Large language model 506 can then generate the missing information (e.g., missing dependency 510) based on source code 504.

[0064] In example 500, the server can generate plug-in metadata 522 based on installation steps 508, dependencies 510, run commands 512, configuration information 514, tool information 516, programming language 518, and category 520. Plug-in metadata 522 is standardized deployment information. The client can parse plug-in metadata 522 to obtain information for generating an installation script.

[0065] In some embodiments, when deploying a plug-in to an application by running an installation script, the client can detect whether the dependencies are already installed in the runtime environment. If the dependencies are not installed in the runtime environment, the client can install them. In some embodiments, the client can inject configuration information into the runtime environment. The client can then install the plug-in by running the run command in the deployment information. In this way, the automation level and environmental adaptability of plug-in deployment can be improved. This approach can reduce deployment failures caused by missing dependencies or incomplete configuration, thereby improving the stability and success rate of the deployment process.

[0066] In some embodiments, the client can detect whether the deployment information conflicts with information about another plugin already deployed in the application. If such a conflict is detected, the client can display a warning message indicating the conflict. This approach can reduce plugin operation anomalies or system instability caused by issues such as inconsistent dependency versions, port usage, and configuration conflicts, thereby improving the security and controllability of the plugin deployment process.

[0067] Figure 6 FIG. 6 is a flow chart illustrating an example process 600 for deploying a plug-in at a client according to some embodiments of the present disclosure. Figure 6 As shown, in box 602, the client can obtain plug-in metadata from the server. The plug-in metadata may include dependencies, run commands, and configuration information. In box 604, the client can detect whether the dependencies specified in the plug-in metadata (e.g., Node, Python packages, etc.) have been installed in the system environment. If the dependencies have been installed, the process 600 can proceed to box 608. If the dependencies are not installed, the process 600 can proceed to box 606. In box 606, the client can automatically install the missing dependencies. In box 608, the client can inject the configuration information specified in the plug-in metadata. In box 610, the client can install the plug-in by executing the run command in the plug-in metadata. In box 612, the client can start the installed plug-in to complete the deployment of the plug-in.

[0068] During the plugin deployment process, if the client detects a conflict between the plugin metadata and information about another already deployed plugin, it can display a warning message in the application indicating the conflict. For example, if the plugin name in the plugin metadata is the same as the name of an already deployed plugin, the client can prompt the user to change the plugin name.

[0069] Figure 7 FIG. 7 is a schematic diagram showing an example 700 of automatically deploying a plug-in from a plug-in market in an application according to some embodiments of the present disclosure. Figure 7As shown, in example 700, component 702 can be presented in the user interface of an application. Component 702 is used to display a plugin marketplace in the application. Component 702 can include multiple components associated with multiple deployable plugins. In example 700, component 702 includes component 704 for plugin 1, component 706 for plugin 2, and component 708 for plugin 3. Plugins 1, 2, and 3 have not yet been deployed to the application.

[0070] In example 700, the server has generated the deployment information of plugin 1 and plugin 2 based on the descriptions of plugin 1 and plugin 2 and using the language model, so plugin 1 and plugin 2 can be automatically deployed to the application on the client. In contrast, the server has not yet obtained the deployment information of plugin 3, so plugin 3 cannot be automatically deployed to the application on the client. Figure 7 As shown, a prompt message "Easy Configuration" may be presented in components 704 and 706 to inform the user that Plugin 1 and Plugin 2 support automatic deployment. When the user clicks the Add button 710 in component 704, the client can retrieve plugin metadata for Plugin 1 and environmental information about the application's runtime environment from the server. The client can then generate an installation script for Plugin 1 based on the plugin metadata and environmental information. The client can then execute the generated installation script to complete the automatic deployment of Plugin 1. After Plugin 1 is deployed, component 712 may be presented in the application's user interface to inform the user that Plugin 1 has been successfully added.

[0071] In example 700, when the user clicks Add button 714 in component 708, since plugin 3 does not support automatic deployment, a component for manually configuring the deployment information of plugin 3 may be presented in the application's user interface. Compared to plugin 3, the deployment process for plugins 1 and 2 is much simpler, significantly improving the user experience.

[0072] In some embodiments, the client can receive additional configuration information input by the user through the application's user interface. The client can then generate a plug-in installation script based on the deployment information received from the server and the additional configuration information input by the user. In this way, the client allows the user to enter user-specific configuration information (e.g., a specific database link, user account information, etc.), thereby supporting more plug-in deployment scenarios and improving the flexibility and versatility of plug-in deployment.

[0073] Figure 8 FIG. 8 is a schematic diagram showing an example 800 of a user inputting additional configuration information during the process of deploying a plug-in according to some embodiments of the present disclosure. Figure 8As shown, in example 800, component 802 can be presented in the user interface of an application. Component 802 is used to display a plug-in marketplace in the application. Component 802 can include multiple components associated with multiple deployable plug-ins. In example 800, component 802 includes component 804 for plug-in 1, and plug-in 1 has not yet been deployed to the application.

[0074] In example 800, the server has generated the deployment information of plug-in 1 based on the description of plug-in 1 and using the language model, so plug-in 1 supports being automatically deployed to the application on the client. Figure 8 As shown, a prompt message "Easy Configuration" may be presented in component 804 to inform the user that plugin 1 supports automatic deployment. When the user clicks the Add button 806 in component 804, the client can retrieve plugin metadata for plugin 1 and environmental information about the application's runtime environment from the server. Component 808 may then be presented in the application's user interface. Component 808 prompts the user to enter additional configuration information and receives this information via input box 810. For example, the user can enter a link to a specific database in input box 810, allowing the application to access data in that database through plugin 1.

[0075] In example 800, after the user enters additional configuration information in input box 810, they can click confirmation button 812. The client can then generate an installation script for plug-in 1 based on the deployment information of plug-in 1 obtained from the server, the additional configuration information entered by the user, and the environment information. The client can then execute the generated installation script to automatically deploy plug-in 1. After plug-in 1 is deployed, component 814 can be displayed on the application's user interface to prompt the user that plug-in 1 has been successfully added.

[0076] Figure 9 FIG. 9 is a block diagram of an apparatus 900 for generating deployment information of a plug-in used in an application according to some embodiments of the present disclosure. Figure 9 As shown, apparatus 900 includes a plug-in description acquisition module 902 configured to acquire a plug-in description, where the description is written in a natural language and includes information for deploying the plug-in. Apparatus 900 also includes a deployment information generation module 904 configured to generate deployment information for the plug-in based on the description using a language model. Furthermore, apparatus 900 also includes a deployment information sending module 906 configured to send the deployment information to a client, where the deployment information is used to generate an installation script for the plug-in.

[0077] In some embodiments, the deployment information generation module 904 includes: an installation step generation module, which is configured to generate the installation steps of the plug-in, the dependencies required to run the plug-in, the running commands for installing the plug-in, and the configuration information associated with the plug-in based on the description and using a language model.

[0078] In some embodiments, the installation step generation module includes: a missing information determination module, configured to determine that generation of target information based on the description fails, the target information includes any one of installation steps, dependencies, run commands, or configuration information; a source code acquisition module, configured to obtain the source code of the plug-in; and a source code usage module, configured to generate target information based on the source code using a language model.

[0079] In some embodiments, the deployment information generation module 904 further includes: a tool information generation module configured to generate at least one of the following based on the description using a language model: tool information describing the functionality of the plug-in, the programming language of the plug-in, or the category of the plug-in.

[0080] In some embodiments, the deployment information sending module 906 includes: a metadata generating module configured to standardize the deployment information into plug-in metadata in a unified format; and a metadata sending module configured to send the plug-in metadata to the client.

[0081] In some embodiments, the apparatus 900 further includes: a plug-in adding module configured to add a plug-in to a deployable plug-in list in response to generating deployment information; and a plug-in list sending module configured to send the deployable plug-in list to the client for display in the application.

[0082] In some embodiments, the deployment information sending module 906 includes: a request receiving module configured to send deployment information to the client in response to receiving a request from the client to deploy the plug-in in the application.

[0083] In some embodiments, the plugin is a server-side component that encapsulates and exposes services using the Model Context Protocol (MCP).

[0084] Figure 10A block diagram of an apparatus 1000 for generating a plug-in for deployment in an application according to some embodiments of the present disclosure is shown. The apparatus 1000 includes a deployment request sending module 1002, which is configured to send a request to a server to obtain deployment information of the plug-in in response to detecting a user interaction indicating deployment of the plug-in in the application. The apparatus 1000 also includes a deployment information receiving module 1004, which is configured to receive deployment information from the server, the deployment information being generated based on a description of the plug-in and using a language model, and the description being written in a natural language. The apparatus 1000 also includes an installation script generating module 1006, which is configured to generate an installation script for the operating environment of the application based on the deployment information. The apparatus 1000 also includes a plug-in deployment module 1008, which is configured to deploy the plug-in into the application by running the installation script.

[0085] In some embodiments, the deployment information is standardized into plug-in metadata in a unified format, and the installation script generation module 1006 includes a metadata using module configured to generate an installation script based on the plug-in metadata.

[0086] In some embodiments, the metadata using module includes: an environment information obtaining module configured to obtain environment information associated with the running environment of the application; and an environment information using module configured to generate an installation script based on the environment information and the plug-in metadata.

[0087] In some embodiments, the deployment information includes installation steps of the plug-in, dependencies on which the plug-in depends, a running command for installing the plug-in, and configuration information associated with the plug-in.

[0088] In some embodiments, the deployment information further includes at least one of the following: tool information describing the functionality of the plug-in, the programming language of the plug-in, or the category of the plug-in.

[0089] In some embodiments, the plug-in deployment module 1008 includes: a dependency detection module configured to detect whether dependencies are already installed in the running environment; and a dependency installation module configured to install dependencies in response to dependencies not being installed in the running environment.

[0090] In some embodiments, the plug-in deployment module 1008 includes: a configuration information injection module configured to inject configuration information into the execution environment; and a run command use module configured to install the plug-in by running the run command.

[0091] In some embodiments, the device 1000 also includes: a conflict detection module, configured to detect whether the deployment information conflicts with information of another plug-in that has been deployed in the application; and an information prompt module, configured to display prompt information indicating the conflict in response to detecting the existence of a conflict.

[0092] It can be understood that by utilizing the apparatus 900 or apparatus 1000 of the present disclosure, at least one of the many advantages that can be achieved by the method or process described above can be achieved. For example, in this way, the server can utilize the language model to automatically generate the deployment information of the plug-in, thereby reducing the time the user spends on deploying the plug-in, reducing the requirements for the user's professional knowledge, and improving the success rate of the plug-in deployment. In addition, compared to directly generating the system command for deploying the plug-in by the language model, the method of generating the deployment information by the language model and then generating the installation script based on the deployment information can improve the accuracy of the deployment, improve the success rate of the deployment, and also enhance the control capability of the environmental security, and prevent the system command generated by the language model from damaging the system environment.

[0093] Figure 11 1 is a block diagram of a device 1100 capable of implementing various embodiments of the present disclosure. Figure 1 The server 102 or client 104 is shown. Figure 11 As shown, the device 1100 includes a central processing unit (CPU) and / or a graphics processing unit (GPU) 1101, which can perform various appropriate actions and processes according to computer program instructions stored in a read-only memory (ROM) 1102 or computer program instructions loaded from a storage unit 1108 into a random access memory (RAM) 1103. Various programs and data required for the operation of the device 1100 can also be stored in the RAM 1103. The CPU / GPU 1101, the ROM 1102, and the RAM 1103 are connected to each other via a bus 1104. An input / output (I / O) interface 1105 is also connected to the bus 1104. Although not shown in FIG. Figure 11 As shown in FIG, device 1100 may further include a co-processor.

[0094] Various components in device 1100 are connected to I / O interface 1105, including an input unit 1106, such as a keyboard and mouse; an output unit 1107, such as various types of displays and speakers; a storage unit 1108, such as a magnetic disk and optical disk; and a communication unit 1109, such as a network card, a modem, a wireless communication transceiver, etc. Communication unit 1109 allows device 1100 to exchange information / data with other devices via a computer network such as the Internet and / or various telecommunication networks.

[0095] The various methods or processes described above may be executed by the CPU / GPU 1101. For example, in some embodiments, the methods may be implemented as a computer software program tangibly embodied in a machine-readable medium, such as the storage unit 1108. In some embodiments, part or all of the computer program may be loaded and / or installed onto the device 1100 via the ROM 1102 and / or the communication unit 1109. When the computer program is loaded into the RAM 1103 and executed by the CPU / GPU 1101, one or more steps or actions in the methods or processes described above may be performed.

[0096] In some embodiments, the methods and processes described above may be implemented as a computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for executing various aspects of the present disclosure.

[0097] Computer-readable storage medium can be a tangible device that can keep and store the instructions used by the instruction execution device.Computer-readable storage medium can be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device or any suitable combination thereof.More specific examples (non-exhaustive list) of computer-readable storage medium include: a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanical encoding device, for example, a punch card or a convex structure in a groove having instructions stored thereon, and any suitable combination thereof.Computer-readable storage medium used herein is not interpreted as a transient signal itself, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagated by waveguides or other transmission media (for example, light pulses by fiber optic cables), or electrical signals transmitted by wires.

[0098] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device, or downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network can include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions to be stored in the computer-readable storage medium in each computing / processing device.

[0099] The computer program instructions for performing the disclosed operation can be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data or source code or the object code written in any combination of one or more programming languages, programming languages ​​include object-oriented programming languages, and conventional procedural programming languages.Computer-readable program instructions can be performed completely on a user's computer, partially on a user's computer, performed as an independent software package, partly on a user's computer and partly on a remote computer, or performed completely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer by any type of network-including local area network (LAN) or wide area network (WAN), or can be connected to an external computer (such as utilizing an internet service provider to connect by the internet). In certain embodiments, by utilizing the state information of computer-readable program instructions to carry out personalized customization electronic circuits, such as programmable logic circuits, field programmable gate arrays (FPGAs) or programmable logic arrays (PLA), this electronic circuit can perform computer-readable program instructions, thereby realizing various aspects of the present disclosure.

[0100] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing device, thereby producing a machine, so that when these instructions are executed by the processing unit of the computer or other programmable data processing device, a device is generated that implements the functions / actions specified in one or more blocks in the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, where these instructions cause the computer, programmable data processing device, and / or other device to operate in a specific manner. Thus, the computer-readable medium storing the instructions comprises an article of manufacture that includes instructions for implementing various aspects of the functions / actions specified in one or more blocks in the flowchart and / or block diagram.

[0101] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device, so that a series of operational steps are performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to implement the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0102] The flow charts and block diagrams in the accompanying drawings show the possible architecture, functions and operations of the devices, methods and computer program products according to multiple embodiments of the present disclosure. In this regard, each box in the flow chart or block diagram can represent a part of a module, program segment or instruction, and the part of the module, program segment or instruction contains one or more executable instructions for realizing the prescribed logical function. In some alternative implementations, the functions marked in the box can also occur in a sequence different from that marked in the accompanying drawings. For example, two consecutive boxes can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart, can be implemented by a special hardware-based system that performs the prescribed function or action, or can be implemented by a combination of special hardware and computer instructions.

[0103] The embodiments of the present disclosure have been described above. The above description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is selected to best explain the principles of the embodiments, practical applications, or technical improvements to existing technologies, or to enable other persons skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for generating deployment information for a plug-in used in an application, comprising: Obtain a description of the plug-in, where the description is written in a natural language and includes information for deploying the plug-in; Based on the description, using a language model to generate deployment information of the plug-in; as well as The deployment information is sent to the client, and the deployment information is used to generate an installation script for the plug-in.

2. The method according to claim 1, wherein generating the deployment information of the plug-in based on the description using the language model comprises: Based on the description, the language model is used to generate installation steps for the plug-in, dependencies required for running the plug-in, a running command for installing the plug-in, and configuration information associated with the plug-in.

3. The method according to claim 2, wherein, based on the description, using the language model to generate the installation steps of the plug-in, the dependencies on which the plug-in depends for running, the run command for installing the plug-in, and the configuration information associated with the plug-in comprises: determining that generation of target information based on the description fails, the target information including any one of the installation steps, the dependencies, the run commands, or the configuration information; Obtain the source code of the plug-in; as well as The target information is generated based on the source code using the language model.

4. The method according to claim 2, wherein generating the deployment information of the plug-in based on the description using the language model further comprises: Based on the description, the language model is used to generate at least one of the following: tool information describing a function of the plug-in, a programming language of the plug-in, or a category of the plug-in.

5. The method according to claim 1, wherein sending the deployment information to the client comprises: Standardizing the deployment information into plug-in metadata in a unified format; as well as The plug-in metadata is sent to the client.

6. The method according to claim 1, further comprising: In response to generating the deployment information, adding the plug-in to a list of deployable plug-ins; as well as The deployable plug-in list is sent to the client for display in the application.

7. The method according to claim 1, wherein sending the deployment information to the client comprises: In response to receiving a request from the client to deploy the plug-in in the application, the deployment information is sent to the client.

8. The method according to claim 1, wherein the plug-in is a server-side component that encapsulates and exposes services using the Model Context Protocol (MCP).

9. A method for deploying a plug-in in an application, comprising: In response to detecting a user request instructing to deploy the plug-in in the application, sending a request to a server for obtaining deployment information of the plug-in; receiving the deployment information from the server, wherein the deployment information is generated based on a description of the plug-in and using a language model, and the description is written in a natural language; generating an installation script for the operating environment of the application based on the deployment information; as well as The plug-in is deployed to the application by running the installation script.

10. The method according to claim 9, wherein the deployment information is standardized into plug-in metadata in a unified format, and generating the installation script for the runtime environment of the application based on the deployment information comprises: The installation script is generated based on the plug-in metadata.

11. The method of claim 10, wherein generating the installation script based on the plug-in metadata comprises: Obtaining environment information associated with the operating environment of the application; as well as The installation script is generated based on the environment information and the plug-in metadata.

12. The method according to claim 9, wherein the deployment information includes installation steps of the plug-in, dependencies on which the plug-in depends for running, a running command for installing the plug-in, and configuration information associated with the plug-in. 13 . The method according to claim 12 , wherein the deployment information further comprises at least one of the following: tool information describing a function of the plug-in, a programming language of the plug-in, or a category of the plug-in.

14. The method according to claim 12, wherein deploying the plug-in into the application by running the installation script comprises: Detecting whether the dependency has been installed in the operating environment; as well as In response to the dependency not being installed in the execution environment, the dependency is installed.

15. The method according to claim 12, wherein deploying the plug-in into the application by running the installation script comprises: Injecting the configuration information into the operating environment; as well as Install the plug-in by running the run command.

16. The method according to claim 9, further comprising: Detecting whether the deployment information conflicts with information of another plug-in already deployed in the application; as well as In response to detecting the presence of the conflict, prompt information indicating the conflict is displayed.

17. A device for generating deployment information of a plug-in used in an application, comprising: A plug-in description acquisition module is configured to acquire a description of the plug-in, where the description is written in a natural language and includes information for deploying the plug-in; A deployment information generation module is configured to generate deployment information of the plug-in based on the description and using a language model; as well as The deployment information sending module is configured to send the deployment information to the client, where the deployment information is used to generate an installation script for the plug-in.

18. A device for deploying a plug-in in an application, comprising: a deployment request sending module configured to, in response to detecting a user request instructing to deploy the plug-in in the application, send a request to a server for obtaining deployment information of the plug-in; a deployment information receiving module configured to receive the deployment information from the server, wherein the deployment information is generated based on the description of the plug-in and using a language model, and the description is written in a natural language; An installation script generation module is configured to generate an installation script for the operating environment of the application based on the deployment information; as well as The plug-in deployment module is configured to deploy the plug-in into the application by running the installation script.

19. An electronic device comprising: processor; as well as A memory coupled to the processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to any one of claims 1 to 8 or 9 to 16.

20. A computer program product tangibly stored on a non-transitory computer readable medium and comprising machine-executable instructions which, when executed, cause a machine to implement the method of any one of claims 1 to 8 or 9 to 16.

Images