Intelligent agent-based service execution method, device, terminal, system and medium

Abstract

The invention discloses an agent-based service execution method and device, a terminal, a system and a medium, and belongs to the technical field of artificial intelligence. The method comprises the following steps: based on received user input information and card configuration information issued by a card management platform, interacting with a background system through an intelligent agent to obtain a target card code package corresponding to a service required by a user from the card management platform; creating a micro-container matched with the code language type of the target card code package through the intelligent agent, wherein the micro-container is isolated from a running container of the intelligent agent; and controlling a microcontainer to load the target card code package through the intelligent agent so as to execute the business logic of the target card code package, rendering and generating a card view, and displaying the card view in a dialogue interface of the intelligent agent. According to the embodiment of the invention, the service execution stability of the agent can be improved.

Description

Technical Field

[0001] This application belongs to the field of artificial intelligence technology, and in particular relates to a service execution method, device, terminal, system and medium based on intelligent agents. Background Technology

[0002] With the continuous development of Artificial Intelligence (AI) technology, intelligent agents, or AIAgents, are gradually evolving from information retrieval tools into digital proxies capable of performing complex services. Users can issue natural language commands to intelligent agents, which then execute the services indicated by those commands. However, if code vulnerabilities, logical errors, or malicious behavior exist during the intelligent agent's execution of the service provided by the service provider, it may lead to operational crashes, or even directly cause the entire system containing the intelligent agent to collapse. This creates a single point of failure that triggers systemic risks, significantly reducing the stability of the intelligent agent's service execution. Summary of the Invention

[0003] This application provides a service execution method, apparatus, terminal, system, and medium based on intelligent agents, which can improve the stability of intelligent agents executing services.

[0004] In a first aspect, embodiments of this application provide a service execution method based on an intelligent agent, comprising: interacting with a backend system through an intelligent agent based on received user input information and card configuration information issued by the card management platform to obtain a target card code package corresponding to the service required by the user from the card management platform; creating a micro-container through the intelligent agent that matches the code language type of the target card code package, wherein the micro-container is isolated from the running container of the intelligent agent; controlling the micro-container through the intelligent agent to load the target card code package to execute the business logic of the target card code package, rendering and generating a card view and displaying it in the dialog interface of the intelligent agent.

[0005] Secondly, embodiments of this application provide a service execution system based on an intelligent agent, comprising: a card management platform storing card code packages uploaded by service providers and card configuration information corresponding to the card code packages, each card code package being used to execute a service; a user terminal, communicatively connected to the card management platform, having an application program containing an intelligent agent, the intelligent agent being configured to interact with a backend system based on received user input information and card configuration information issued by the card management platform, to obtain a target card code package corresponding to the service required by the user from the card management platform, to create a micro-container matching the code language type of the target card code package, the micro-container being isolated from the running container of the intelligent agent, controlling the micro-container to load the target card code package to execute the business logic of the target card code package, rendering and generating a card view and displaying it in the dialogue interface of the intelligent agent; and a backend system, communicatively connected to the user terminal, configured to interact with the intelligent agent based on received user input information and card configuration information issued by the card management platform.

[0006] Thirdly, embodiments of this application provide a service execution device based on an intelligent agent, comprising: a communication module, configured to interact with a backend system through an intelligent agent based on received user input information and card configuration information issued by the card management platform, to obtain a target card code package corresponding to the service required by the user from the card management platform; a micro-container management module, configured to create a micro-container matching the code language type of the target card code package through the intelligent agent, wherein the micro-container is isolated from the running container of the intelligent agent; and configured to control the micro-container to load the target card code package through the intelligent agent, to execute the business logic of the target card code package, render and generate a card view and display it in the dialog interface of the intelligent agent.

[0007] Fourthly, embodiments of this application provide a user terminal, including: a processor and a memory storing computer program instructions; the processor executes the computer program instructions to implement the agent-based service execution method of the first aspect.

[0008] Fifthly, embodiments of this application provide a computer-readable storage medium storing computer program instructions, which, when executed by a processor, implement the agent-based service execution method of the first aspect.

[0009] In a sixth aspect, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the agent-based service execution method of the first aspect.

[0010] This application provides a service execution method, apparatus, terminal, system, and medium based on an intelligent agent. The user terminal, based on user input information and card configuration information issued by a card management platform, interacts with the backend through an intelligent agent to determine the user's required service. It then obtains the target card code package corresponding to the required service from the card management platform. A micro-container is created by the intelligent agent, and the obtained target card code package is loaded into the micro-container to execute the business logic of the target card code package. A card view is rendered and displayed in the intelligent agent's dialog interface. The micro-container is isolated from the intelligent agent's runtime container. The business logic of the target card code package runs within the micro-container. If an exception occurs during the execution of the target card code package's business logic, the exception can be isolated in the micro-container and will not propagate to the intelligent agent's runtime container, avoiding a single point of failure that could cause the system containing the intelligent agent to crash, thereby improving the stability of the intelligent agent's service execution. Attached Figure Description

[0011] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings used in the embodiments of this application will be briefly introduced below. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0012] Figure 1 This is a schematic diagram of the structure of an agent-based service execution system provided in an embodiment of this application; Figure 2 A schematic diagram of the structure of an agent-based service execution system provided in another embodiment of this application; Figure 3 A schematic diagram of the structure of an agent-based service execution system provided in another embodiment of this application; Figure 4 A flowchart of a service execution method for an intelligent agent provided in an embodiment of this application; Figure 5 A schematic diagram illustrating an example of a service execution method based on an intelligent agent provided in this application for implementing a movie ticketing service; Figure 6 A schematic diagram illustrating an example of a microcontainer provided in an embodiment of this application; Figure 7 A schematic diagram illustrating an example of security protection for a microcontainer provided in an embodiment of this application; Figure 8 A schematic diagram illustrating an example of an intelligent agent provided in an embodiment of this application; Figure 9 A schematic diagram of the structure of a service execution device based on an intelligent agent provided in an embodiment of this application; Figure 10 This is a schematic diagram of the structure of a user terminal provided in an embodiment of this application. Detailed Implementation

[0013] The features and exemplary embodiments of various aspects of this application will be described in detail below. To make the objectives, technical solutions, and advantages of this application clearer, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments. It should be understood that the specific embodiments described herein are only intended to explain this application and not to limit it. For those skilled in the art, this application can be implemented without some of these specific details. The following description of the embodiments is merely to provide a better understanding of this application by illustrating examples. It should be noted that the acquisition, storage, use, and processing of information and data in the embodiments of this application are all authorized by users or relevant organizations and comply with the relevant provisions of national laws and regulations.

[0014] With the continuous development of AI technology, intelligent agents, or AI agents, are gradually evolving from information retrieval tools into digital proxies capable of executing complex services. Users can issue natural language commands to intelligent agents, which then execute the services indicated by those commands. However, during the process of an intelligent agent running the business logic of services provided by a service provider, code vulnerabilities, logical errors, or malicious behavior can lead to operational crashes, or even directly cause the entire system containing the intelligent agent to collapse. This creates a single point of failure that triggers systemic risks, significantly reducing the stability of the services executed by the intelligent agent. Furthermore, in order for the intelligent agent's runtime container to run the services provided by the service provider, the technology stack of the services provided by the service provider must be completely consistent with the technology stack of the intelligent agent. Service providers unfamiliar with the intelligent agent's technology stack need to adapt to this unfamiliar technology stack when developing services, which is more difficult. Moreover, if the intelligent agent's technology stack is updated, the service provider also needs to update the technology stack of the services it provides, increasing maintenance complexity. In other solutions, the service provider can also provide H5 links, which users can interact with within the agent's dialogue interface to navigate to a separate H5 page. However, this method requires leaving the agent's environment, and the actions on the new page cannot be recorded by the agent, which disrupts the continuity of the agent's service. Furthermore, the agent cannot provide users with relevant historical information about actions on the new page.

[0015] This application provides a service execution method, apparatus, terminal, system, and medium based on intelligent agents. The intelligent agent can create micro-containers to host the execution of card code packages. Each card code package corresponds to a service, and each card code package runs in a separate micro-container. The micro-containers are isolated from the intelligent agent's runtime container. If an exception occurs while the micro-container is executing the business logic of the card code package, the impact of the exception can be limited to the micro-container, preventing a single point of failure from causing the system where the intelligent agent resides to crash, thereby improving the stability of the intelligent agent's service execution. Furthermore, the micro-containers created by the intelligent agent are matched to the code language type of the card code package. When the development language of the intelligent agent differs from that of the card code package, the micro-container can parse the card code package and execute the business logic. Micro-containers enable multi-technology stack compatibility for intelligent agents, eliminating the need for service providers to adapt to unfamiliar technology stacks during service development. Updates to the intelligent agent's technology stack do not require the service provider to synchronously update the service's technology stack, thus reducing development and maintenance complexity. Moreover, the agent can dynamically load the card code package of the service and directly render the card view corresponding to the card code package on the agent's dialogue interface without jumping to a new page. This ensures the continuity and immersion of the agent's service. The agent can also record relevant information about the user's operation on the card, so as to provide the user with historical information related to the execution of the service when needed.

[0016] The following describes the agent-based service execution method, device, terminal, system, medium, and program products provided in this application.

[0017] To facilitate understanding, we will first provide a brief explanation of the architecture of an agent-based service execution system. Figure 1 This is a schematic diagram of the structure of an agent-based service execution system provided in an embodiment of this application, as shown below. Figure 1 As shown, the agent-based service execution system may include a card management platform 11, a user terminal 12, and a back-end system 13.

[0018] The card management platform 11 stores card code packages uploaded by service providers, along with corresponding card configuration information. Service providers are third-party service providers responsible for the development, testing, and deployment of card code packages. Service providers can register on the card management platform 11 and upload their compliant card service packages and card configuration information to it. The card management platform 11 can be used for configuring and managing card code packages and card configuration information. In some examples, the card management platform 11 may include a card resource management platform 111 and a card configuration management platform 112. The card resource management platform stores and manages card code packages, while the card configuration management platform 112 stores and manages card configuration information. Each card code package executes a specific service. Different services correspond to different service packages. Running the card code package executes the corresponding service. For example, services that a card code package can execute include, but are not limited to, payment services, benefits services, ticketing services, coffee ordering services, food delivery services, medical services, public utility payment services, travel services, live streaming services, and navigation services. In some examples, the card code package can be implemented as a Local Model Context Protocol (MCP) service unit, which may be called a LocalMCP Server. The card code package can also be implemented in other forms, which are not limited here. In some examples, the card code package may include a service aggregation layer, a business logic layer, and an interface abstraction layer. The service aggregation layer can call an Application Programming Interface (API) to obtain raw service data from the service provider. The business logic layer can execute business logic; specifically, the business logic layer can have a built-in state machine engine to execute multi-step business flows. The interface abstraction layer can expose a single call endpoint to agent 122 so that agent 122 can call the card code package. Card configuration information includes information that describes the card package, such as, but not limited to, the card code package's metadata, input / output specifications, version information, card function description information, dependency information, etc. The card code package's metadata identifies the card code package. The functionality of the card management platform 11 can be implemented by one or more devices, which are not limited here.

[0019] User terminal 12 can communicate with card management platform 11. User terminal 12 has application 121, which includes agent 122. User terminal 12 can serve as a host environment for executing services. User terminal 12 can provide a secure and isolated execution environment for card code packages. Agent 122 can serve as the interaction hub for service execution and can call various functions of the card code package. In some examples, the card code package may include, but is not limited to, standardized interfaces, business logic code, resource data, and metadata for identifying the card code package. The card code package can be called by agent 122 through standardized interfaces. The business logic code in the card code package and the code of agent 122 itself belong to different files; that is, the business logic code in the card code package and the code of agent 122 itself are decoupled. Resource data refers to the resources required to run the business logic code; for example, resource data may include images, sounds, etc., and is not limited here. Metadata for identifying the card code package may include, but is not limited to, one or more of the following: protocol type, service domain, service type, service provider, version number, and dependent services. The protocol type in the metadata represents the protocol type of the card code package. For example, if the card code package is a Local MCPServer unit, the protocol type in the metadata could be "mcp". The service domain represents the domain of the service corresponding to the card code package. For example, the service domain may include, but is not limited to, the catering, office, IoT, finance, healthcare, and transportation domains. The service type represents the specific service type of the card code package within its service domain. For example, service types in the catering domain may include, but are not limited to, coffee, fast food, bread, and hot pot. The service provider can be a representation of the service provider. The version number can be the version number of the card code package. Dependent services represent other services that the service corresponding to the card code package depends on. Metadata can be formatted using a hierarchical namespace. For example, metadata can be formatted as "protocol type.service domain.service type.service provider," such as "mcp.fnb.coffee.ShopXX," which indicates that the protocol type of the card code package is MCP, the service domain is food and beverage (fnb), the service type is coffee, and the service provider is a store named shopXX. User terminal 12 may include, but is not limited to, devices such as mobile phones, tablets, smart bracelets, smartwatches, and e-paper devices. In this embodiment, when the intelligent agent 122 needs to load the card code package, the intelligent agent 122 can create a micro-container specifically for loading the card code package.

[0020] The backend system 13 is communicatively connected to the user terminal 12. The backend system 13 can act as a decision-making hub, analyzing user intent and deciding which card code package the intelligent agent 122 should download and run. In some examples, the backend system 13 may include a large language model 131, whose speech analysis and reasoning capabilities can be used to analyze user intent and determine the card code package corresponding to the service required by the user. The functionality of the backend system 13 can be implemented by one or more devices, and is not limited thereto.

[0021] In some embodiments, the agent-based service execution system may further include a service provider platform. Figure 2 This is a schematic diagram of the structure of an agent-based service execution system provided in another embodiment of this application. Figure 2 and Figure 1 The difference is that, Figure 2 The agent-based service execution system shown also includes a service provider platform 14. The service provider platform 14 is owned by a service provider. The service provider platform 14 is communicatively connected to the user terminal 12. During the loading of the card code package into the microcontainer created by the agent 122, the microcontainer can interact with the service provider platform 14, which can provide the microcontainer with the service data required to run the card code package and generate a card view. The functionality of the service provider platform 14 can be implemented by one or more devices, and is not limited thereto.

[0022] In some embodiments, the card code package may include a complex function card code package, which is used to implement services with composite functions. The complex function card code package may be a large-volume card code package representing a highly complex service. A highly complex service can be decomposed into multiple component code packages with clearly defined responsibility boundaries. For example, a highly complex service may be a shopping service, which can be decomposed into sub-functions such as order query, payment processing, and logistics tracking. Correspondingly, the order query sub-function corresponds to the order query component code package, the payment processing sub-function corresponds to the payment processing component code package, and the logistics tracking sub-function corresponds to the logistics tracking component code package. During the process of loading the complex function card code package into the micro-container and executing business logic, the component code packages need to be called. The agent-based service execution system in the above embodiments may also include a component management platform. Figure 3 This is a schematic diagram of the structure of an agent-based service execution system provided in another embodiment of this application. Figure 3 and Figure 2 The difference is that, Figure 3The agent-based service execution system shown may also include a component management platform 15. The component management platform 15 communicates and interacts with the user terminal 12. The component management platform 15 and the card management platform 11 may be the same platform or different platforms, which is not limited here. The component management platform 15 stores component code packages uploaded by service providers. Each component code package is used to implement a sub-function, and there is a correspondence between the component code package and the component identifier. Service providers may pre-upload component code packages containing multiple sub-functions obtained by decomposing complex services corresponding to complex function card code packages to the component management platform 15, and may also register the metadata of component code packages on the component management platform 15. The metadata of component code packages includes component identifiers, and may also include, but is not limited to, one or more of the following: version number, input / output interface specifications, dependency information, loading strategy identifier, etc. The version number supports multiple versions coexisting and canary releases. The input / output interface specifications can define the calling protocol of the component code package. Dependency information can characterize the collaborative relationship between the component code package and other component code packages. The loading strategy identifier can identify whether the component code package is loaded synchronously or asynchronously. The functionality of the component management platform 15 can be implemented by a single or multiple devices, and is not limited to this.

[0023] The specific details of the steps performed by the aforementioned card management platform 11, user terminal 12, backend system 13, service provider platform 14, and component management platform 15 in the agent-based service execution method will be explained in detail below.

[0024] This application also provides a service execution method based on intelligent agents, which can be applied to the user terminal in the above embodiments, that is, the service execution method based on intelligent agents can be executed by the user terminal. Figure 4 A flowchart of a service execution method for an intelligent agent provided in an embodiment of this application is shown below. Figure 4 As shown, the agent-based service execution method may include steps S201 to S203.

[0025] In step S201, based on the received user input information and the card configuration information issued by the card management platform, the intelligent agent interacts with the backend system to obtain the target card code package corresponding to the service required by the user from the card management platform.

[0026] The intelligent agent can receive user input, which can be natural language information, specifically text, voice, images, video, etc., without limitation. If the user input is non-text data such as voice, images, or video, it can be converted into text data. When the intelligent agent is triggered to start, it can request card configuration information from the card management platform. The card management platform can send the card configuration information it supports to the intelligent agent in a list format. After obtaining the card configuration information, the intelligent agent can cache it locally on the user terminal for subsequent use. User input reflects user intent, and card configuration information indicates the card code packages supported by the card management platform, i.e., the services that the user terminal can implement by loading card code packages. The intelligent agent interacts with the backend system based on user input and card configuration information. The backend system can provide the intelligent agent with card configuration information corresponding to the service of the user intent. The intelligent agent can then use the card configuration information of the service corresponding to the user intent to obtain the card code package of the service corresponding to the user intent from the card management platform.

[0027] In some examples, the user terminal can send user input information and card configuration information to the backend system via an intelligent agent; the intelligent agent receives target card configuration information from the backend system based on the user input information and card configuration information, which is the card configuration information corresponding to the service required by the user, obtained through inference; the intelligent agent obtains the target card code package indicated by the target card configuration information from the card management platform. After receiving the user input information and card configuration information, the backend system analyzes and infers from the user input information and card configuration information to extract the user intent and obtain the card configuration information of the service corresponding to the user intent. The service corresponding to the user intent is the service required by the user. The analysis and inference of user input information and card configuration information by the backend system can be implemented through a large language model in the backend system. For example, the large language model in the backend system can analyze the user input information based on deep learning algorithms to obtain the user intent, and then combine it with the function and applicable scenarios of the service described in the card configuration information to select the card configuration information that matches the user intent as the target card configuration information. The backend system can feed back all the card configuration information matching the user's intent to the agent, or it can feed back only a portion of the card configuration information matching the user's intent; this is not limited. For example, the backend system can feed back metadata that identifies the card code package or data that indicates the download path of the card code package from the card configuration information matching the user's intent to the agent. The communication protocol for transmitting the target card configuration information between the backend system and the user terminal is not limited here; for example, the communication protocol can use the Server-Sent Events (SSE) protocol, but it is not limited to this. The agent can send a card code package request to the card management platform. The card code package request can include the target card configuration information, and the agent downloads the card code package indicated by the target card configuration information from the card management platform through the card code package request. The target card code package is the card code package used to implement the service required by the user, or in other words, the target card code package is the card code package indicated by the target card configuration information.

[0028] In step S202, a micro-container matching the code language type of the target card code package is created by the intelligent agent.

[0029] To safely load the target card code package, the agent creates a micro-container for loading it. The agent can create micro-containers for various code languages, including but not limited to JavaScript (JS), React Native (RN), and Weex. After downloading the target card code package, the agent determines its code language type and creates and starts a micro-container matching that type. The created micro-container's code language type is consistent with the target card code package's. The micro-container is isolated from the agent's runtime container. A micro-container can be viewed as a lightweight, secure runtime environment isolated from the agent's runtime container. While the micro-container can reside within the agent's runtime container, it is isolated from it; exceptions generated during code execution within the micro-container are isolated within the micro-container and do not propagate to the agent's runtime container.

[0030] In step S203, the agent controls the micro-container to load the target card code package, execute the business logic of the target card code package, render and generate a card view, and display it in the agent's dialogue interface.

[0031] The micro-container can include a logic layer and a rendering layer. The logic layer can be used to load the target card code package and execute its business logic. The rendering layer can be used to render and generate card views. The generated card views are displayed in the agent's dialogue interface, rather than through interface navigation or opening a new page. Interactive page components capable of overlay rendering, such as standard interfaces, reality windows, and augmented reality (AR) interfaces, can be directly provided through the card code package. The user terminal can also interact with the service provider platform corresponding to the card view through the micro-container based on user actions, obtaining service data. If needed, the card views in the agent's dialogue interface can be updated based on the service data to implement the corresponding service.

[0032] For example, Figure 5 A schematic diagram illustrating an example of implementing a movie ticketing service using an agent-based service execution method provided in this application embodiment, as shown below. Figure 5As shown, the service provider platform 14 may include a service developer platform 141. The service developer platform 141 produces card code packages, which may include a rights card code package 161, a movie ticketing card code package 162, etc., and uploads the card code packages to the card management platform 11. The card resource management platform 111 in the card management platform 11 stores rights card code packages 161, movie ticketing card code packages 162, etc., and the card configuration management platform 112 stores a card configuration information list, which includes card configuration information of rights card code package 161, card configuration information of movie ticketing card code package 162, etc. The user terminal 12 has an application 121, which includes an agent 122. The agent 122 receives the user input information "I want to buy movie tickets for movie A1", obtains the card configuration information list from the card management platform 11, and sends the user input information "I want to buy movie tickets for movie A1" and the card configuration information list to the backend system 13. The backend system 13, based on the user input "I want to buy movie tickets for movie A1" and the card configuration information list, determines that the user's intention is to buy movie tickets and the service required is movie ticketing service. It then feeds back the card configuration information corresponding to the movie ticketing service to the intelligent agent 122. The intelligent agent 122 requests the card code package corresponding to the movie ticketing service indicated by the card configuration information from the card management platform 11. The intelligent agent 122 creates a micro-container 123 to load the obtained card code package corresponding to the movie ticketing service. During the execution of the business logic of the card code package, the user terminal 12 can also interact with the movie ticketing service platform 142 to obtain service data. The movie ticketing service platform 142 may belong to the service provider platform 14. The micro-container 123 renders a card view 17 for movie seat selection based on the service data and displays this card view 17 in the intelligent agent's dialogue interface.

[0033] In this embodiment, the user terminal, based on user input information and card configuration information issued by the card management platform, interacts with the backend through an intelligent agent to determine the services required by the user. It then obtains the target card code package corresponding to the required services from the card management platform, creates a micro-container through the intelligent agent, loads the obtained target card code package into the micro-container, executes the business logic of the target card code package, renders and generates a card view, and displays the card view in the intelligent agent's dialog interface. The micro-container is isolated from the intelligent agent's runtime container. The business logic of the target card code package runs within the micro-container. If an anomaly occurs during the execution of the target card code package's business logic, the anomaly can be isolated within the micro-container and will not propagate to the intelligent agent's runtime container, avoiding a single point of failure that could cause the system where the intelligent agent resides to crash, thereby improving the stability of the services executed by the intelligent agent. The code language type of the micro-container created by the agent matches the code language type of the target card code package. When the agent's development language differs from the card code package's development language, the micro-container matching the target card code package can parse the target card code package, thus achieving multi-technology stack compatibility for the agent. Service providers do not need to adapt to unfamiliar technology stacks during service development. If the agent's technology stack is updated, the service provider does not need to synchronously update the card code package's technology stack, thereby reducing development and maintenance difficulty. Furthermore, the agent dynamically loads the service's card code package, directly rendering the corresponding card view on the agent's dialogue interface without requiring navigation to a new page. This ensures the continuity and immersiveness of the agent's service. The agent can also record user interaction information for cards, providing historical information when needed.

[0034] In some embodiments, the microcontainer may include a logic layer and a rendering layer, the logic layer including a language engine. The logic layer can be used to process the target card code package and execute its business logic. The rendering layer can be used to render and display a card view. The language engine is used to parse the target card code package, converting it into machine-executable code. The user terminal can control the microcontainer to load the target card code package via an intelligent agent, start the language engine in the logic layer that matches the code language type of the target card code package to parse the target card code package, obtain the executable code; process the executable code through the logic layer to execute business logic and obtain rendering data; transmit the rendering data to the rendering layer through the logic layer; and render and display the card view based on the rendering data. The code language type of the language engine in the microcontainer's logic layer is consistent with the code language type of the target card code package, allowing the language engine in the logic layer to directly parse the target card code package. The executable code is the code executable by the microcontainer, obtained after parsing by the language engine.

[0035] In some examples, the rendering layer in the microcontainer can be used to perform one or more of the following functions: build and render card views; convert style information in the rendering data transmitted from the logic layer into style information that conforms to the rendering layer's recognition criteria; cache rendering data; call the native components of the user terminal where the agent resides; call the native rendering functions of the user terminal; and capture user operations on the user terminal.

[0036] The logic layer in the micro-container is used to perform one or more of the following functions: generate new rendering data in real time based on changes in the card view; load, display, and unload the target card code package; execute page routing for the card corresponding to the target card code package; retrieve exceptions during the execution of the business logic of the target card code package; and run the micro-container's voice engine.

[0037] For example, Figure 6 A schematic diagram illustrating an example of a microcontainer provided in an embodiment of this application, as shown below. Figure 6 As shown, the micro-container 30 may include a rendering layer 31 and a logic layer 32. The rendering layer 31 may include component rendering functionality 311, style rendering functionality 312, rendering caching functionality 313, native component functionality 314, animation acceleration functionality 315, and event capturing functionality 316. The logic layer 32 may include data management functionality 321, lifecycle functionality 322, page routing functionality 323, exception capturing functionality 324, and a language engine 325.

[0038] The component rendering function 311 is used to construct and present the card view. The style rendering function 312 is used to convert the style information in the rendering data transmitted from the logic layer into style information that conforms to the recognition standard of the rendering layer. The rendering caching function 313 is used to cache rendering data. When the card view is updated but has the same content as the original card view, the rendering layer 31 can directly call the cached rendering data corresponding to the same content, thereby speeding up the generation of the card view and improving rendering performance. The native component function 314 is used to call the native components of the user terminal where the agent resides. In some high-performance scenarios with high performance requirements such as computing speed, response latency, rendering smoothness, resource efficiency, and data processing throughput, simply using the capabilities of the rendering layer itself may not meet the performance requirements of high-performance scenarios. The rendering layer can use the native capabilities of the user terminal by calling the native components of the user terminal to improve performance. For example, in high-performance scenarios, the rendering layer can call the native components of the user terminal such as maps, videos, and cameras. Animation acceleration function 315 is used to call the native rendering function of the user terminal. In some scenarios that require rendering complex animations, the rendering capability of the micro-container's rendering layer itself is insufficient to achieve smooth operation of complex animations. The rendering layer can call the native rendering function of the user terminal to provide hardware acceleration support, such as calling the user terminal's graphics processing unit (GPU). Event capture function 316 is used to capture user operations on the user terminal. Users can operate on the card view displayed in the dialogue interface of the smart agent. These operations can be called user operations. The rendering layer can capture these user operations, which may include, but are not limited to, click operations, long press operations, and other gesture operations.

[0039] Data management function 321 is used to generate new rendering data in real time based on changes in the card view. Changes in the card view may be caused by user actions; for example, if a user interacts with the card view on the main coffee order page to enter the coffee menu page, the card view needs to change from the main coffee order page's card view to the coffee menu page's card view. The newly generated rendering data can be used to render new card views, thus achieving real-time updates of rendering data and card views during the card code package's operation. Lifecycle function 322 is used to execute the loading, display, and unloading of the target card code package. In other words, lifecycle function 322 manages and defines the lifecycle of the card code package, which can include loading, displaying, and unmounting. Page routing function 323 is used to execute page routing for the cards corresponding to the target card code package. Page routing can be used for navigation and management of pages corresponding to the card views of the card code package. Page routing supports, but is not limited to, the following routing events: Push (page open), Pop (page return), Redirect (page redirect), and Reload (page reload). The `Open Page` function opens a new page and pushes it onto the top of the page stack. The `Back Page` function closes the current page and returns to the previous page. The `Redirect Page` function replaces the current page with a new one. The `Reload Page` function preserves the current page but requires reloading and rendering its data. The exception handling function 324 is used to capture exceptions during the execution of the target card's code package's business logic; exception information can then be processed by the intelligent agent. The language engine 325 supports multiple code language types, including but not limited to JS, RN, and Weex engines.

[0040] In some embodiments, the user terminal can process the executable code through the logic layer in the micro-container of the intelligent agent, determine the page to be displayed based on the page route, and obtain the rendering data of the page to be displayed. The rendering layer can render and generate a card view of the page to be displayed based on the rendering data of the page to be displayed. In some examples, the card view needs to be updated due to user operation. The rendering layer can capture the user operation and the view element operated by the user, and notify the logic layer; the logic layer determines the page to be displayed based on the view element operated by the user and the page route. The logic layer can generate differential rendering data between the page to be displayed and the original page. The differential rendering data includes the different corresponding rendering data of the page to be displayed and the original page. The rendering data of the page to be displayed transmitted from the logic layer to the rendering layer is the differential rendering data between the page to be displayed and the original page. That is, after the logic layer generates the differential rendering data, it transmits the differential rendering data to the rendering layer.

[0041] When the agent loads the target card code package, it can launch a micro-container that matches the code language type of the target card code package. The logic layer of the micro-container will run the target card code package and enter the lifecycle management of the target card code package, that is, execute... Figure 6 The lifecycle function 322. Execution. Figure 6 The page routing function 323 in the code loads the first page and triggers... Figure 6 The component rendering function 311 in the middle rendering layer constructs the card view, realizing component rendering of the card view, and then executes the style rendering function 312 to realize style rendering of the card view. After the card view is rendered, the rendering caching function 313 can be executed to cache the rendering data. However, when the user performs user operations on the displayed card view, through... Figure 6 The event capture function 316 in the code captures and detects view elements that have been interacted with by the user, and notifies the logic layer. The logic layer then executes the executable code in the target card's code package to handle the event based on the user action. If the user action causes a change in the card view, it can be handled through... Figure 6 The data management function 321 in the middle transmits rendering data that changes the card view, such as differential rendering data, to the rendering layer, triggering... Figure 6 The component rendering function 311 in the middle rendering layer constructs the card view, realizes the component rendering of the card view, and then executes the style rendering function 312 to realize the style rendering of the card view and realize the update of the card view.

[0042] In some embodiments, the microcontainer can capture exceptions during the execution of the target card code package, thereby ensuring that exceptions in the target card code package do not affect the normal operation of the agent or other target card code packages. The user terminal can capture exceptions during the execution of the business logic of the target card code package through the microcontainer, generating exception information; the exception information is transmitted to the agent through the microcontainer, and the agent performs exception handling on the microcontainer based on the exception information. The exception information can describe the exception generated during the execution of the business logic of the target card code package. The agent handles the exception indicated by the exception information. Exception handling can include terminating the processing of the abnormal business logic or restarting the processing of the abnormal business logic. For example, exception handling includes: controlling the microcontainer to unload the target card code package, removing the microcontainer loaded with the target card code package, or generating a card view to indicate the exception. The agent controls the microcontainer to unload the target card code package to close the target card code package and prevent the exception from continuing to have adverse effects. The agent can also remove the microcontainer loaded with the target card code package to close the microcontainer and prevent the exception from continuing to have adverse effects. A card view indicating the anomaly is generated and displayed in the agent's dialogue interface, alerting the user to the occurrence of the anomaly and awaiting further instructions from the user, so that subsequent operations can be performed according to the user's instructions.

[0043] In some examples, the target card code package includes exception identification code, which is used to capture and handle exceptions during the execution of the target card code package. Before the agent captures exceptions during the execution of the business logic of the target card code package through the micro-container, the exception identification code in the target card code package can be executed through the micro-container to identify and handle exceptions during the execution of the business logic. That is, the micro-container security protection in this application embodiment may include two levels of protection: the first level of protection is the business-level exception handling of the target card code package, and the second level of protection is the exception handling at the micro-container level. The second level of protection is effective when there are exceptions that are not captured by the first level of protection. The exception handling of the micro-container itself captures exceptions that are not identified by the exception identification code in the target card code package. That is, the exceptions captured by the micro-container include those that are not identified by the exception identification code.

[0044] For example, Figure 7 A schematic diagram illustrating an example of security protection for a microcontainer provided in an embodiment of this application, as shown below. Figure 7 As shown, in the target card code package micro-container 30 that loads the movie ticketing service, the rendering layer 31 renders and generates a card view of the movie ticket seating selection. The business-level exception handling 33 of the target card code package in the logic layer 32 first catches exceptions, filtering out some. The micro-container-level exception handling 34 in the logic layer 32 also catches exceptions, specifically those not recognized by the business-level exception handling 33 of the target card code package. Figure 7 The cross in the code indicates an exception. The microcontainer-level exception handling 34 captures the exception and can transmit it to the microcontainer management unit 35 in the agent 122, where the microcontainer management unit 35 performs exception handling 36.

[0045] By employing a two-tiered security protection mechanism—namely, business-level exception handling for the target card code package and micro-container-level exception handling—it can be ensured that an abnormal target card code package will not affect the agent or other micro-containers, thereby improving the stability of the agent's services.

[0046] In some embodiments, the agent includes a microcontainer management unit. The agent can create multiple microcontainers. The microcontainer management unit can manage multiple microcontainers simultaneously. For example, Figure 8 A schematic diagram illustrating an example of an intelligent agent provided in an embodiment of this application, such as... Figure 8 As shown, the intelligent agent 122 may include two micro-containers 30, each loading a different target card code package. For example, one micro-container 30 loads a target card code package for benefits services, while the other micro-container 30 loads a target card code package for movie ticketing services. Each micro-container 30 includes a rendering layer 31 and a logic layer 32. The functions of the rendering layer 31 and the logic layer 32 can be found in [reference needed]. Figure 6 This will not be elaborated upon further here; for the sake of clarity, Figure 8 The functions in rendering layer 31 are collectively referred to as the first functional unit 37, and the functions in logic layer 32 are collectively referred to as the second functional unit 38. The first functional unit in rendering layer 31 can capture events triggered by user operations and notify logic layer 32 of the events. Logic layer 32 executes the business logic of the target card code package, generates rendering data, and transmits the rendering data to rendering layer 31, where a card view 39 is generated. Microcontainer management unit 35 can manage these two microcontainers 30. Microcontainer management unit 35 may have data transmission function 351, permission management function 352, configuration management function 353, exception handling function 354, and performance monitoring function 355. Data transmission function 351 can be used for data interaction between multiple microcontainers. Specifically, when different microcontainers 30 need to interact when executing their respective business logic of the target card code package, the different microcontainers 30 transmit data through microcontainer management unit 35. Microcontainer management unit can receive data to be transmitted from one microcontainer 30 through data transmission function 351 and then transmit the data to another microcontainer 30. The access control function 352 can manage the application's access permissions to the target card code package. The configuration management function 353 can manage card configuration information. The exception handling function 354 can handle exceptions captured by the logic layer. The performance monitoring function 355 can monitor the runtime performance of the microcontainer to facilitate performance optimization.

[0047] In some embodiments, the card code package may include a simple function card code package and a complex function card code package. A simple function card code package is used to implement a single-function service and includes business logic code that implements that single function. The simple function card code package can be a small-volume card code package representing a low-complexity service. If the card code package indicated by the target card configuration information is a simple function card code package, the micro-container in the agent can adopt a synchronous loading mode to directly load the simple function card code package, execute the business logic code that implements the single function, and directly obtain the rendered complete service interface. The service interface is implemented as the card view in this embodiment, and the micro-container quickly presents the card corresponding to the simple function card code package through the synchronous loading mode.

[0048] The specific content of the complex function card code package can be found in the relevant descriptions in the above embodiments. In some examples, the complex function card code package may have a lightweight identifier, which indicates that the card code package is a lightweight code package. A card code package with a lightweight identifier can be identified as a complex function card code package. If the card code package indicated by the target card configuration information is a complex function card code package, the agent can adopt an asynchronous loading mode to load the complex function card code package and execute the business logic code of the composite function framework. During the execution of the business logic code of the composite function framework, it is necessary to call multiple sub-functions decomposed from the composite function. When a sub-function needs to be called, the component code package corresponding to the sub-function can be called asynchronously. Specifically, the component code package indicated by the component identifier can be obtained through the component identifier.

[0049] Correspondingly, the user terminal can control the micro-container to load complex function card code packages via an intelligent agent. During the execution of the business logic code within the framework of the composite function, the micro-container requests the component code corresponding to the component identifier from the component management platform. The micro-container then loads the requested component code package, executes the business logic within the component code package, renders and generates a card view, and displays it. When the micro-container loads the complex function card code package, it obtains the component identifier of the required sub-function during the execution of the business logic code within the framework of the service function. It can then request the component code package indicated by the component identifier from the component management platform. After downloading and obtaining the component code package, the micro-container can load the component code package and render and generate the card. For example, the component management platform stores component code packages such as order placement component code packages, payment component code packages, and after-sales component code packages. If the service corresponding to the complex function card code package is a food delivery service, the food delivery service can be decomposed into sub-functions such as order placement and payment. The intelligent agent sends the user input information "I want to order food delivery" and the card configuration information obtained from the card management platform to the backend system. The backend system determines the target card configuration information based on the user input information and the card configuration information. The target card configuration information corresponds to the food delivery service. The intelligent agent downloads the complex function card code package for the food delivery service from the card management platform, and the intelligent agent starts... A micro-container loads the complex function card code package, and the micro-container executes the business logic code of the composite function framework in the complex function card code package. During the execution of the business logic code, the component identifiers in the complex function card code package can be obtained. The component identifiers correspond to the ordering component code package and the payment component code package. The ordering component code package and the payment component code package indicated by the component identifier are downloaded from the component management platform. The micro-container loads the ordering component code package and the payment component code package, and can render and generate the order card view and the payment card view, and display the order card view and the payment card view in the intelligent agent's dialogue interface.

[0050] When a user triggers a complex service, the micro-container loads the necessary business logic from the complex function card code package and provides a lightweight component identifier. This identifier indicates the component code package to be invoked. The micro-container can use the component identifier as an addressing credential to initiate a component retrieval request. The component management platform can accurately retrieve the corresponding independent component code package based on the component identifier and feed it back to the micro-container in the agent. The micro-container loads the component code package and displays the rendered card view in the agent's session interface. This asynchronous loading process enables delayed loading and resource optimization for complex services.

[0051] By employing both synchronous and asynchronous loading modes, a loading strategy can be flexibly selected based on the complexity of the service. Synchronous loading of simple function card code packages maintains fast response times, balancing processing efficiency and user experience. Asynchronous loading of complex function card code packages allows for dynamic loading of component code packages to implement sub-functions on demand, significantly reducing the initial load and avoiding redundant resource consumption. This optimizes agent performance and efficiently utilizes resources, resolving the performance issues caused by the requirement to initialize all functions upon agent startup in traditional architectures.

[0052] This application also provides a service execution device based on intelligent agents. Figure 9 This is a schematic diagram of the structure of a service execution device based on an agent provided in an embodiment of this application, as shown below. Figure 9 As shown, the agent-based service execution device 400 may include a communication module 401 and a microcontainer management module 402.

[0053] The communication module 401 can be used to interact with the back-end system through an intelligent agent based on the received user input information and the card configuration information issued by the card management platform, so as to obtain the target card code package corresponding to the service required by the user from the card management platform.

[0054] The micro-container management module 402 can be used to create micro-containers that match the code language type of the target card code package through an agent, with the micro-containers being isolated from the agent's runtime container; and to control the micro-containers to load the target card code package through the agent, so as to execute the business logic of the target card code package, render and generate a card view and display it in the agent's dialog interface.

[0055] In some embodiments, the communication module 401 can be used to: send user input information and card configuration information to the backend system through an intelligent agent; receive target card configuration information fed back by the backend system based on user input information and card configuration information through an intelligent agent, wherein the target card configuration information is the card configuration information corresponding to the user's required service obtained through inference; and obtain the target card code package indicated by the target card configuration information from the card management platform through an intelligent agent.

[0056] In some embodiments, the microcontainer includes a logic layer and a rendering layer, with the logic layer including a language engine. The microcontainer management module 402 can be used to control the microcontainer to load the target card code package, start the language engine in the logic layer that matches the code language type of the target card code package to parse the target card code package and obtain the executable code; process the executable code through the logic layer to execute business logic and obtain rendering data; transmit the rendering data to the rendering layer through the logic layer; and render and generate a card view based on the rendering data and display it.

[0057] In some embodiments, the microcontainer management module 402 can be used to: process the executed code through the logic layer, determine the page to be displayed based on the page route, and obtain the rendering data of the page to be displayed.

[0058] In some embodiments, the microcontainer management module 402 may also be used to: capture user operations and view elements subject to user operations through the rendering layer and notify the logic layer before processing the executed code through the logic layer and determining the page to be displayed based on the page path.

[0059] The micro-container management module 402 can be used to: determine the page to be displayed through the logic layer based on the view elements operated by the user and the page route; wherein, the rendering data of the page to be displayed transmitted from the logic layer to the rendering layer is the differential rendering data between the page to be displayed and the original page.

[0060] In some embodiments, the microcontainer management module 402 can also be used to: capture exceptions in the process of executing the business logic of the target card code package through the microcontainer and generate exception information; transmit the exception information to the intelligent agent through the microcontainer and perform exception handling on the microcontainer according to the exception information; wherein, the exception handling includes: controlling the microcontainer to unload the target card code package, removing the microcontainer loaded with the target card code package, or generating a card view for indicating the exception.

[0061] In some embodiments, the target card code package includes exception identification code. The micro-container management module 402 can also be used to: before capturing exceptions in the process of executing the business logic of the target card code package through the micro-container and generating exception information, execute the exception identification code in the target card code package through the micro-container to identify and handle exceptions in the process of executing the business logic; wherein, the exceptions captured by the micro-container include exceptions not identified by the exception identification code.

[0062] In some embodiments, the rendering layer is used to perform any one or more of the following functions: constructing and presenting card views; converting style information in the rendering data transmitted from the logic layer into style information that conforms to the rendering layer's recognition standards; caching rendering data; calling the native components of the user terminal where the agent resides; calling the native rendering functions of the user terminal; and capturing user operations on the user terminal.

[0063] In some embodiments, the logic layer is used to perform any one or more of the following functions: generate new rendering data in real time according to changes in the card view; load, display and unload the target card code package; perform page routing for the card corresponding to the target card code package; obtain exceptions in the process of executing the business logic of the target card code package; and run the speech engine of the microcontainer.

[0064] In some embodiments, the agent creates multiple micro-containers. When different micro-containers need to interact to execute the business logic of their respective target card code packages, the different micro-containers transmit data through the micro-container management module 402.

[0065] In some embodiments, the card code package includes a complex function card code package, which includes the business logic code of the framework of the complex function and component identifiers corresponding to multiple sub-functions decomposed from the complex function.

[0066] The micro-container management module 402 can be used to: control the micro-container to load complex function card code packages through an intelligent agent; request component code corresponding to component identifiers from the component management platform during the execution of business logic code of the framework of composite functions; load the requested component code package through the micro-container; execute the business logic in the component code package; render and generate card views and display them.

[0067] It should be noted that the agent-based service execution device 400 is a device corresponding to the agent-based service execution method described above. All implementation methods in the above method embodiments are applicable to the embodiments of this device and can achieve the same technical effect.

[0068] This application also provides a user terminal. Figure 10 This is a schematic diagram of the structure of a user terminal provided in an embodiment of this application, as shown below. Figure 10 As shown, the user terminal 500 includes a memory 501, a processor 502, and a computer program stored in the memory 501 and capable of running on the processor 502.

[0069] In some examples, the processor 502 described above may include a central processing unit (CPU), or an application-specific integrated circuit (ASIC), or one or more integrated circuits that may be configured to implement the embodiments of this application.

[0070] Memory 501 may include read-only memory (ROM), random access memory (RAM), disk storage media devices, optical storage media devices, flash memory devices, and electrical, optical, or other physical / tangible memory storage devices. Therefore, typically, memory includes one or more tangible (non-transitory) computer-readable storage media (e.g., memory devices) encoded with software including computer-executable instructions, and when the software is executed (e.g., by one or more processors), it is operable to perform operations described with reference to the agent-based service execution method according to embodiments of this application.

[0071] The processor 502 runs a computer program corresponding to the executable program code by reading the executable program code stored in the memory 501, so as to implement the agent-based service execution method in the above embodiments.

[0072] In some examples, the user terminal 500 may also include a communication interface 503 and a bus 504. For example... Figure 10 As shown, the memory 501, processor 502, and communication interface 503 are connected through bus 504 and complete communication with each other.

[0073] The communication interface 503 is mainly used to enable communication between various modules, devices, units, and / or equipment in the embodiments of this application. Input devices and / or output devices can also be connected through the communication interface 503.

[0074] Bus 504 includes hardware, software, or both, that couples the components of user terminal 500 together. For example, and not limitingly, bus 504 may include an Accelerated Graphics Port (AGP) or other graphics bus, an Enhanced Industry Standard Architecture (EISA) bus, a Front Side Bus (FSB), a Hyper Transport (HT) interconnect, an Industry Standard Architecture (ISA) bus, an Infinite Bandwidth Interconnect, a Low Pin Count (LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-E) bus, a Serial Advanced Technology Attachment (SATA) bus, a Video Electronics Standards Association Local Bus (VLB) bus, or other suitable buses, or a combination of two or more of these. Where appropriate, bus 504 may include one or more buses. Although specific buses are described and illustrated in the embodiments of this application, this application considers any suitable bus or interconnection.

[0075] This application also provides a computer-readable storage medium storing computer program instructions. When these computer program instructions are executed by a processor, they can implement the agent-based service execution method described in the above embodiments and achieve the same technical effect. To avoid repetition, further details are omitted here. The aforementioned computer-readable storage medium may include non-transitory computer-readable storage media, such as read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks, etc., and is not limited thereto.

[0076] This application also provides a computer program product, which includes a computer program. When the computer program is executed by a processor, it implements the agent-based service execution method in the above embodiments and can achieve the same technical effect. To avoid repetition, it will not be described again here.

[0077] It should be clarified that the various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. For system embodiments, device embodiments, user terminal embodiments, computer-readable storage medium embodiments, and computer program product embodiments, relevant parts can be referred to the description section of the method embodiments. This application is not limited to the specific steps and structures described above and shown in the figures. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of this application. Furthermore, for the sake of brevity, detailed descriptions of known methods and techniques are omitted here.

[0078] The aspects of this application have been described above with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It should be understood that each block in the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that these instructions, executable via the processor of the computer or other programmable data processing apparatus, enable the implementation of the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams. Such a processor can be, but is not limited to, a general-purpose processor, a special-purpose processor, a special application processor, or a field-programmable logic circuit. It is also understood that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can also be implemented by dedicated hardware performing the specified functions or actions, or can be implemented by a combination of dedicated hardware and computer instructions.

[0079] Those skilled in the art will understand that the above embodiments are exemplary and not restrictive. Different technical features appearing in different embodiments can be combined to achieve beneficial effects. Based on a study of the drawings, specification, and claims, those skilled in the art should be able to understand and implement other variations of the disclosed embodiments. In the claims, the term "comprising" does not exclude other means or steps; the quantifier "a" does not exclude a plurality; the terms "first" and "second" are used to identify names and not to indicate any particular order. No reference numerals in the claims should be construed as limiting the scope of protection. The functionality of multiple parts appearing in the claims can be implemented by a single hardware or software module. The appearance of certain technical features in different dependent claims does not mean that these technical features cannot be combined to achieve beneficial effects.

Claims

1. A service execution method based on intelligent agents, characterized in that, include: Based on the received user input information and the card configuration information issued by the card management platform, the intelligent agent interacts with the back-end system to obtain the target card code package corresponding to the service required by the user from the card management platform; The agent creates a micro-container that matches the code language type of the target card code package, and the micro-container is isolated from the agent's runtime container; The agent controls the micro-container to load the target card code package, execute the business logic of the target card code package, render and generate a card view, and display it in the agent's dialog interface.

2. The method according to claim 1, characterized in that, The process of obtaining the target card code package corresponding to the user's required service from the card management platform by interacting with the backend system through an intelligent agent based on received user input information and card configuration information issued by the card management platform includes: The intelligent agent sends the user input information and the card configuration information to the backend system. The intelligent agent receives target card configuration information fed back by the backend system based on the user input information and the card configuration information. The target card configuration information is the card configuration information corresponding to the user's required service, which is obtained through inference. The intelligent agent obtains the target card code package, which is indicated by the target card configuration information, from the card management platform.

3. The method according to claim 1, characterized in that, The microcontainer includes a logic layer and a rendering layer, wherein the logic layer includes a language engine; The step of loading the target card code package into the micro-container via the intelligent agent, executing the business logic of the target card code package, rendering and generating a card view, and displaying it in the intelligent agent's dialogue interface includes: The intelligent agent controls the micro-container to load the target card code package, and starts the language engine in the logic layer that matches the code language type of the target card code package to parse the target card code package and obtain the executable code. The executed code is processed by the logic layer to execute business logic and obtain rendering data; The rendering data is transmitted from the logic layer to the rendering layer, and the rendering layer renders and generates a card view based on the rendering data and displays it.

4. The method according to claim 3, characterized in that, The process of processing the executed code through the logic layer to execute business logic and obtain rendering data includes: The executed code is processed by the logic layer, and the page to be displayed is determined according to the page route to obtain the rendering data of the page to be displayed.

5. The method according to claim 4, characterized in that, Before the executed code is processed by the logic layer and the page to be displayed is determined based on the page path, the following steps are also included: The rendering layer captures user actions and the view elements affected by those actions, and then notifies the logic layer. The step of processing the executed code through the logic layer and determining the page to be displayed based on the page route includes: The logic layer determines the page to be displayed based on the view elements that have been interacted with by the user and the page route; The rendering data of the page to be displayed, which is transmitted from the logic layer to the rendering layer, is the differential rendering data between the page to be displayed and the original page.

6. The method according to claim 1, characterized in that, Also includes: The micro-container captures exceptions during the execution of the business logic of the target card code package and generates exception information. The abnormal information is transmitted to the intelligent agent through the micro-container, and the intelligent agent performs abnormal handling on the micro-container based on the abnormal information. The exception handling includes: controlling the microcontainer to unload the target card code package, removing the microcontainer loaded with the target card code package, or generating a card view to indicate the exception.

7. The method according to claim 6, characterized in that, The target card code package includes anomaly detection code; Before capturing exceptions during the execution of the business logic of the target card code package via the micro-container and generating exception information, the method further includes: The exception recognition code in the target card code package is executed by a micro-container to identify and handle exceptions during the execution of business logic. Among them, the exceptions captured by the micro-container include exceptions that were not recognized by the exception recognition code.

8. The method according to claim 3, characterized in that, The rendering layer is used to perform one or more of the following functions: Build and render card views; Convert the style information in the rendering data transmitted from the logic layer into style information that conforms to the recognition standard of the rendering layer; Cache rendering data; Invoke the native components of the user terminal where the intelligent agent resides; Invoke the native rendering function of the user terminal; Capture user operations on the user terminal.

9. The method according to claim 3, characterized in that, The logic layer is used to perform one or more of the following functions: New rendering data is generated in real time based on changes in the card view; Execute the loading, display, and unloading of the target card code package; Execute the page route for the card corresponding to the target card code package; Detect exceptions that occur during the execution of the business logic of the target card code package; A voice engine that runs microcontainers.

10. The method according to claim 1, characterized in that, The intelligent agent includes a micro-container management unit, and the intelligent agent creates multiple micro-containers; When different microcontainers need to interact with each other to execute their respective target card code packages' business logic, the different microcontainers transmit data through the microcontainer management unit.

11. The method according to claim 1, characterized in that, The card code package includes a complex function card code package, which includes the business logic code of the framework of the complex function and component identifiers corresponding to multiple sub-functions decomposed from the complex function; The step of loading the target card code package into the micro-container via the intelligent agent, executing the business logic of the target card code package, rendering and generating a card view, and displaying it in the intelligent agent's dialogue interface includes: The intelligent agent controls the micro-container to load the complex function card code package, and during the execution of the business logic code of the composite function framework, requests the component code corresponding to the component identifier from the component management platform. The micro-container loads the component code package obtained from the request, executes the business logic in the component code package, renders and generates a card view, and displays it.

12. A service execution system based on intelligent agents, characterized in that, include: The card management platform stores card code packages uploaded by service providers and the card configuration information corresponding to the card code packages. Each card code package is used to execute a service. The user terminal is communicatively connected to the card management platform and has an application program containing an intelligent agent. The intelligent agent is configured to interact with the backend system based on received user input information and card configuration information issued by the card management platform. It retrieves the target card code package corresponding to the user's required service from the card management platform, creates a micro-container that matches the code language type of the target card code package, isolates the micro-container from the intelligent agent's runtime container, controls the micro-container to load the target card code package, executes the business logic of the target card code package, renders and generates a card view, and displays it in the intelligent agent's dialog interface. The backend system is connected to the user terminal and is configured to interact with the intelligent agent based on the received user input information and the card configuration information issued by the card management platform.

13. The system according to claim 12, characterized in that, Also includes: The service provider platform, which is connected to the user terminal, is configured to interact with the micro-container during the execution of business logic in the target card code package by the micro-container, and provide service data for generating the card view.

14. The system according to claim 12, characterized in that, The card code package includes a complex function card code package, which includes the business logic code of the framework of the complex function and component identifiers corresponding to multiple sub-functions decomposed from the complex function; The system also includes: The component management platform communicates and interacts with the user terminal, and stores component code packages uploaded by the service provider. Each component code package is used to implement a sub-function, and the component code package has a corresponding relationship with the component identifier.

15. A service execution device based on an intelligent agent, characterized in that, include: The communication module is used to interact with the back-end system through an intelligent agent based on the received user input information and the card configuration information issued by the card management platform, so as to obtain the target card code package corresponding to the service required by the user from the card management platform; The micro-container management module is used to create a micro-container that matches the code language type of the target card code package through the intelligent agent, the micro-container being isolated from the running container of the intelligent agent; and to control the micro-container to load the target card code package through the intelligent agent, so as to execute the business logic of the target card code package, render and generate a card view, and display it in the dialog interface of the intelligent agent.

16. A user terminal, characterized in that, include: Processor and memory storing computer program instructions; When the processor executes the computer program instructions, it implements the agent-based service execution method as described in any one of claims 1 to 11.

17. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer program instructions that, when executed by a processor, implement the agent-based service execution method as described in any one of claims 1 to 11.

18. A computer program product, characterized in that, It includes a computer program that, when executed by a processor, implements the agent-based service execution method according to any one of claims 1 to 11.

Images