Agent-based user interface processing method, apparatus, device, and medium

Abstract

The application discloses an agent-based user interface processing method and device, equipment and medium, and belongs to the technical field of artificial intelligence. The method comprises the following steps: in response to a user interface request, loading an A2UI generation skill through an A2UI agent, wherein the A2UI generation skill comprises a skill entry index file, a reference knowledge resource set, a stock A2UI message set and a stock interactive event script set; obtaining a target A2UI message based on a target business requirement, the skill entry index file and a first object, wherein the first object comprises one of the reference knowledge resource set and the stock A2UI message set; obtaining a target interactive event script and executing the target interactive event script according to a target interactive event occurring in a user interface, the skill entry index file and the stock interactive event script set through the A2UI agent, and feeding back an execution result to a client. According to the embodiment of the application, the expansion difficulty of the interactive function of the user interface corresponding to the A2UI message can be reduced.

Description

Technical Field

[0001] This application belongs to the field of artificial intelligence technology, and in particular relates to a user interface processing method, apparatus, device and medium based on intelligent agents. Background Technology

[0002] Agent-to-User Interface (A2UI) is an open-source protocol that enables agents to generate rich, interactive user interfaces. A2UI is not executable code, but rather declarative JSON that describes how the user interface (UI) should appear. The client renders the UI, preventing the injection of high-risk scripts into the agent. Users can interact with the agent, which calls a large model to generate A2UI messages and returns them to the client, which then renders the user interface. However, the agent needs to pre-code the user interface's interactive events. When new interaction requirements arise, the agent must be updated through a complete development process involving requirement definition, development, testing, and release to execute the new interactive events, increasing the complexity of expanding the interactive functionality of the user interface corresponding to the A2UI message. Summary of the Invention

[0003] This application provides a user interface processing method, apparatus, device, and medium based on intelligent agents, which can reduce the difficulty of expanding the interactive functions of the user interface corresponding to A2UI messages.

[0004] In a first aspect, embodiments of this application provide a user interface processing method based on an intelligent agent, comprising: responding to a user interface request, loading an A2UI generated skill through an A2UI intelligent agent, wherein the A2UI generated skill includes a skill entry index file, a reference knowledge resource set, a set of existing A2UI messages, and a set of existing interaction event scripts, the skill entry index file being used to guide the A2UI intelligent agent in using the A2UI generated skill; obtaining a target A2UI message corresponding to the target business requirement based on the target business requirement corresponding to the user interface request, the skill entry index file, and a first object, wherein the first object includes one of the reference knowledge resource set and the set of existing A2UI messages, the target A2UI message being transmitted to the client for rendering to generate a user interface; and obtaining and executing a target interaction event script through the A2UI intelligent agent based on the target interaction event occurring in the user interface, the skill entry index file, and the set of existing interaction event scripts, and feeding back the execution result to the client.

[0005] Secondly, embodiments of this application provide a user interface processing device based on an intelligent agent, comprising: a skill loading module, used to load an A2UI generated skill through an A2UI intelligent agent in response to a user interface request; the A2UI generated skill includes a skill entry index file, a reference knowledge resource set, a set of existing A2UI messages, and a set of existing interaction event scripts; the skill entry index file is used to guide the A2UI intelligent agent in using the A2UI generated skill; an A2UI message generation module, used to obtain a target A2UI message corresponding to the target business requirement based on the target business requirement corresponding to the user interface request, the skill entry index file, and a first object; the first object includes one of the reference knowledge resource set and the set of existing A2UI messages; the target A2UI message is transmitted to the client for rendering to generate a user interface; and a script processing module, used to obtain and execute a target interaction event script through the A2UI intelligent agent based on the target interaction event occurring in the user interface, the skill entry index file, and the set of existing interaction event scripts, and to feed back the execution result to the client.

[0006] Thirdly, embodiments of this application provide an electronic device, including: a processor and a memory storing computer program instructions; the processor executes the computer program instructions to implement the agent-based user interface processing method of the first aspect.

[0007] Fourthly, embodiments of this application provide a computer-readable storage medium storing computer program instructions, which, when executed by a processor, implement the agent-based user interface processing method of the first aspect.

[0008] Fifthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the agent-based user interface processing method of the first aspect.

[0009] This application provides a user interface processing method, apparatus, device, and medium based on an intelligent agent. In response to a user interface request, an A2UI intelligent agent for executing A2UI services can load an A2UI generation skill with A2UI message generation and interactive event handling functions. Based on the target business requirements corresponding to the user interface request, the skill entry index file included in the A2UI generation skill, and a first object, a target A2UI message conforming to the target business requirements is obtained. This allows the client to render the target A2UI message, generating and displaying the user interface to the user. When a target interactive event occurs in the user interface, the A2UI intelligent agent can execute the target interactive event script based on the target interactive event, all skill entry files included in the A2UI generation skill, and a set of existing interactive event scripts. The execution result is then fed back to the client, completing the interactive function of the target interactive event. The A2UI generation skill's set of existing interaction event scripts includes pre-generated existing interaction event scripts, so that the execution of interaction events does not rely on hard coding by the agent. If it is necessary to expand the interaction requirements of the user interface, it is only necessary to update the A2UI generation skill, without having to go through the complete R&D process of requirement definition, development, testing, and release again, thereby reducing the difficulty of expanding the interactive functions of the user interface corresponding to the A2UI message. Attached Figure Description

[0010] 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.

[0011] Figure 1 A flowchart illustrating an embodiment of the agent-based user interface processing method provided in this application; Figure 2 A logical schematic diagram illustrating an example of an agent-based user interface processing method provided in an embodiment of this application; Figure 3 A flowchart illustrating an example of a user interface processing method based on an intelligent agent in a network access scenario provided in this application embodiment; Figure 4 A schematic diagram of the structure of an agent-based user interface processing device provided in an embodiment of this application; Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0012] The features and exemplary embodiments of various aspects of this application will be described in detail below. To make the purpose, technical solution, 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 the details in these specific details. The following description of the embodiments is merely to provide a better understanding of this application by illustrating examples of this application. 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. In the embodiments of this application, certain software, components, models, and other existing solutions in the industry may be mentioned. These should be considered as exemplary, and their purpose is only to illustrate the feasibility of implementing the technical solution of this application, but it does not mean that the applicant has or necessarily used such a solution.

[0013] A2UI is an open-source protocol that enables agents to generate rich, interactive user interfaces. Instead of executable code, A2UI is in the form of declarative JSON, describing how the user interface should appear. The client renders the user interface, preventing the injection of high-risk scripts into the agent. Users can interact with the agent, which calls a large model to generate A2UI messages and returns them to the client, which then renders the user interface. However, the agent needs to pre-code the user interface's interactive events. When new interaction requirements arise, the agent must undergo a complete development process involving requirement definition, development, testing, and release to update before it can execute the corresponding interactive events. This increases the difficulty of expanding the interactive functionality of the A2UI user interface. Furthermore, the agent cannot provide services to users during the deployment of the updated agent; services can only resume after the updated agent is successfully deployed, reducing the stability of the agent's service delivery. Each time an agent calls the large model, it needs to assemble a complete A2UI protocol, component catalog prompts, and business knowledge. This assembly consumes a large number of tokens (lexical units), which can impact A2UI generation when tokens are scarce. Furthermore, the large model is inherently uncertain, making it impossible to guarantee that the A2UI messages output by the large model for the same or similar business requests at different times will be consistent and complete. This results in A2UI messages for multiple identical or similar business requests failing to meet standard business processes. Moreover, the A2UI message generation function needs to be integrated into the agent handling comprehensive business operations. Since these agents often handle internal business tasks with high security requirements for the business organization, they are configured with highly secure private large models. However, many of these highly secure private large models do not support A2UI message generation, preventing the generation of user interfaces and failing to meet user requirements.

[0014] This application provides a user interface processing method, apparatus, device, and medium based on intelligent agents. It designs a general A2UI generation skill. An A2UI intelligent agent can load the A2UI generation skill and utilize the skill entry index file, reference knowledge resource set, and existing A2UI message set contained within it to generate A2UI messages corresponding to business requirements. The client renders the A2UI messages to obtain the user interface. When the user interacts with the user interface and generates interaction events, the intelligent agent can obtain and execute the interaction event script based on the skill entry index file and existing interaction event script set contained in the A2UI generation skill, thereby realizing the interactive functions of the user interface. If it is necessary to expand the interactive requirements of the user interface, it is not necessary to go through a complete R&D process of requirement definition, development, testing, and release to obtain new hard-coded code; only the A2UI generation skill needs to be updated, reducing the difficulty of expanding the interactive functions of the user interface corresponding to the A2UI message. Furthermore, the intelligent agent can still provide services to the user during the A2UI generation skill update process, ensuring the stability of the service provided by the intelligent agent. Intelligent agents can leverage A2UI generation skills to load and generate the reference knowledge resources needed for prompts in large models based on business requirements. This effectively reduces the token consumption of prompts and conserves token resources. During the A2UI message determination process, existing A2UI messages corresponding to the same business requirements can be reused, ensuring that the same or similar business requirements can be output with identical A2UI messages, guaranteeing consistency in A2UI message output across different instances of the same or similar business requirements. Furthermore, after generating the A2UI message, the preview function can be used to display the corresponding user interface to the reviewer. Adjustments made by the reviewer to the user interface will refine the A2UI message, ensuring that the output is a definitive, complete, and business-compliant A2UI message. An A2UI agent equipped with A2UI generation skills can complete tasks independently or serve as a sub-agent of an agent handling comprehensive business operations. It can specifically share the tasks of outputting A2UI messages and handling interactive events with the agent handling comprehensive business operations. Based on the private large model configured for the agent handling comprehensive business operations, a large model with A2UI message generation function can be configured for the A2UI agent, solving the problem that the private large model of the agent handling comprehensive business operations cannot generate A2UI messages, thus preventing the generation of user interfaces.

[0015] The following describes the user interface processing method, apparatus, device, medium, and program products based on intelligent agents provided in this application.

[0016] This application provides a user interface processing method based on intelligent agents, which can be applied to scenarios where intelligent agents provide business services that require the generation of user interfaces. This user interface processing method based on intelligent agents can be executed by intelligent agent-based user interface processing devices, equipment, etc., and is not limited thereto. Figure 1 A flowchart of an agent-based user interface processing method provided in an embodiment of this application is shown below. Figure 1 As shown, the agent-based user interface processing method may include steps S101 to S103.

[0017] In step S101, in response to a user interface request, the A2UI generated skill is loaded through the A2UI agent.

[0018] An A2UI agent is an agent used to provide the function of outputting A2UI messages. An A2UI agent can be used as an independent agent or as a sub-agent of a main agent handling integrated business processes; this is not limited to either. A user interface request is used to request a user interface. Upon receiving a user interface request, the A2UI agent can execute the process of outputting A2UI messages. A user interface request can be a request for user interaction with the A2UI agent, or a request for tasks assigned to the A2UI agent by the main agent handling integrated business processes based on user input; this is not limited to either.

[0019] A2UI generation skills are skills used to implement A2UI message generation functionality. A skill can be understood as a tool for achieving a certain function. An A2UI agent loads an A2UI generation skill to obtain and output the target A2UI message. An A2UI generation skill may include, but is not limited to, a skill entry index file, a set of reference knowledge resources, a set of existing A2UI messages, and a set of existing interaction event scripts. The skill entry index file can be implemented as a text file, used to guide the A2UI agent in using the A2UI generation skill. The A2UI agent can understand this skill entry index file, and thus execute the output of A2UI messages and the processing of interaction events based on it. For example, the skill entry index file may include, but is not limited to, a Markdown format file, such as a SKILL.md file. By understanding the skill entry index file, the A2UI agent can learn when to use the A2UI generation skill, the execution flow of the A2UI generation skill, and the index of the data required to output the A2UI message. The set of reference knowledge resources may include reference knowledge resources used to assemble prompts that guide the large model to output A2UI messages. For example, reference knowledge resources may include, but are not limited to, A2UI protocol specifications, component catalog descriptions, and business knowledge. The A2UI protocol specifications can exist in the reference knowledge resources as A2UI protocol specification documents, defining, but not limited to, the format of A2UI messages, the presentation layer (Surface), component rules, and communication protocols to constrain the output of standard A2UI messages from large models. Component catalog descriptions can be implemented as component catalog prompts, including but not limited to user interface component whitelists, component attributes, and component style specifications to avoid generating illegal components. Business knowledge can exist in the form of business knowledge documents, including but not limited to rules for splitting business according to business scenarios, field constraints, data formats, and necessary business data—the logical information required for processing business. The existing A2UI message set includes existing A2UI messages, which are pre-generated A2UI messages that conform to business requirements and standards. When the business requirements corresponding to a user interface request are the same as or similar to the business requirements corresponding to existing A2UI messages in the existing A2UI message set, the existing A2UI messages can be reused. The existing A2UI message set can be updated to meet various user business needs. The existing interaction event script set includes existing interaction event scripts, which are pre-generated scripts for interactive events that can occur in the user interface. When an interaction event occurs, the corresponding existing interaction event script can be executed to complete the user's interaction with the user interface. The existing interaction event scripts in the existing interaction event script set can be updated to update the user interface interaction events supported by the A2UI generation skill. Updating existing interaction event scripts may include, but is not limited to, adding and deleting existing interaction event scripts.For example, if the user interface needs to add new interactive functions, the corresponding interactive event scripts can be added as existing interactive event scripts to the existing interactive event script set, thereby expanding the interactive functions of the user interface corresponding to the A2UI message. During the updating of existing interactive event scripts in the existing interactive event script set, existing interactive event scripts unaffected by the update can still be used, enabling online updates of existing interactive event scripts without affecting the A2UI agent's ability to provide business services to users.

[0020] In some examples, the skill entry index file may include, but is not limited to, one or more of the following: metadata, skill capability description information, skill design goal information, skill usage rule information, resource index, existing A2UI message index, existing interaction event script index, and skill version record. Metadata can be data set in the header of the skill entry index file that describes the identity, attributes, and functions of A2UI-generated skills. The A2UI agent can first load the metadata of the skill entry index file to understand the identity, attributes, and functions of the A2UI-generated skills, thereby enabling the A2UI agent to fully utilize the capabilities of A2UI-generated skills in subsequent processes. The skill capability description information describes the specific capabilities of the A2UI agent, and is more detailed than the portion of the metadata describing the functions of the UI-generated skills, allowing the A2UI agent to understand the more detailed capabilities of the A2UI-generated skills. The skill design goal information describes the design goals of the A2UI-generated skills, reflecting the effects that the A2UI-generated skills can achieve, enabling the A2UI agent to understand the design goals of the A2UI-generated skills, and helping the A2UI agent to better utilize the A2UI-generated skills. The skill usage rules information includes, but is not limited to, the timing of A2UI-generated skill invocation, the invocation scenario information, and the invocation process information. The timing of invocation information describes when to invoke the A2UI-generated skill. The invocation scenario information can be used to describe the scenarios in which the A2UI-generated skill is invoked and / or the scenarios in which invocation is prohibited; it can be implemented as invocation scenarios or prohibited invocation scenarios. The invocation process information can be used to describe the invocation process of the A2UI-generated skill. The resource index is an index of reference knowledge resources and can be implemented as a resource index list, but is not limited to this. The existing A2UI message index can include the correspondence between business requirements and existing A2UI messages in the existing A2UI message set. The existing interaction event script index can include the correspondence between interaction events and existing interaction event scripts in the existing interaction event script set. The skill version record is used to record the version information of the A2UI-generated skill. For example, the skill version record can include one or more of the following: the version number of the A2UI-generated skill, the update time, the updater, and a brief description of the update content.

[0021] To facilitate understanding, the following example illustrates a skill entry index file. For instance, the contents of a skill entry index file might look like this: # Skill: A2UI generated skill ## Metadata ```yaml skill_name: A2UI Interface Generation and Interaction Processing Skill skill_id: a2ui_generate_skill_v1.0 skill_type: A2UI message generation | A2UI message reuse | Interactive event dispatch Author: System Operations / Business Review Team create_time: 2025-XX-XX update_time: 2025-XX-XX dependence: - References / A2UI Protocol, Component Catalog, Business Knowledge Base - scripts / UI interaction event handling script library - a2ui / A2UI message repository that has been reviewed applicable_agent: A2UI intelligent agent trigger_condition: Receives requests for generating interactive UI forms / pop-ups / components or A2UI interface interaction callbacks. ## Capability Description This skill provides A2UI sub-agents with full-process capabilities for A2UI message generation, reuse of historical A2UI messages, and scheduling of UI interaction events.

[0022] - To address new business requirements: Load references / reference materials and drive the large model to generate standard A2UI messages; - For historically similar needs: Based on the semantic index of needs, compliant messages that have been approved in the a2ui / directory can be reused directly without repeatedly calling the large model; - For front-end UI interaction behavior: match scripts in the scripts / directory, automatically execute business logic, and replace hard-coded interaction logic; - Supports closed-loop review: After the review is approved, an index of "requirement-message-script" is automatically created to continuously expand the skill and capability library.

[0023] ## Design Goals - Reduce token consumption for large models and decrease the assembly of repetitive prompts; - Ensure the consistency and completeness of A2UI messages output for the same business requirements; - Enables scripting and scalability of UI interaction logic, allowing business iterations without modifying the core code of the intelligent agent; - Establish a standardized indexing system to support rapid reuse across multiple business scenarios.

[0024] ## Usage Rules ### Timing of Invocation This skill must be enabled if any of the following scenarios are met: - The main AI agent / user issues interactive UI requirements such as "generating forms, filling out forms, selecting pop-ups, and displaying information cards"; - The A2UI previewer triggers UI interaction callback events such as button clicks, form submissions, data resets, and pop-up closures; - After a human completes the review, editing, or rejection of an A2UI message, the status is sent back to the sub-agent.

[0025] ### Prohibited Call Scenarios - Requests that do not require UI generation, such as plain text question answering, data analysis, and command interpretation; - UI generation requirements that are outside the scope of this system's business; - Historical business scenarios that have been discontinued or rendered obsolete ### General Rules for Basic Call Flow - Upon receiving a request, the sub-agent will first search the index list of this document; - Index match successful → Proceed to the [Historical Message Reuse / Script Scheduling] process; - Index match failed → Proceed to the

New Message Generation

[0026] In step S102, based on the target business requirement corresponding to the user interface request, the skill entry index file, and the first object, the target A2UI message corresponding to the target business requirement is obtained.

[0027] The target business requirement is the business requirement corresponding to the user interface request. This requirement can be obtained by analyzing the user interface request using an A2UI agent. The first object includes either the reference knowledge resource set or the existing A2UI message set. The target A2UI message is an A2UI message corresponding to the target business requirement that can be fed back to the client. The target A2UI message can be transmitted to the client for rendering to generate the user interface. After obtaining the target A2UI message, the A2UI agent can send it to the client, which then renders it to obtain the user interface. The client can be the front end of the A2UI agent, the front end of other agents that interact with the A2UI agent, or the front end of an application that interacts with the A2UI agent; there are no limitations on this.

[0028] In some examples, the target business requirement is the same as or similar to a previously existing business requirement. In this case, the first object includes a set of existing A2UI messages, and the target A2UI message corresponding to the target business requirement can be an existing A2UI message in the set of existing A2UI messages. In other examples, the target business requirement is a new type of business requirement, that is, the target business requirement is neither the same as nor similar to a previously existing business requirement. In this case, the first object includes a set of reference knowledge resources, and the target A2UI message corresponding to the target business requirement can be an A2UI message generated by calling the large model based on at least some of the reference knowledge resources in the set of reference knowledge resources.

[0029] In step S103, the A2UI agent obtains the target interaction event script based on the target interaction event occurring in the user interface, the skill entry index file, and the existing interaction event script set, executes it, and sends the execution result back to the client.

[0030] After the user interface is generated and displayed on the client side, the user can interact with the user interface, thereby generating a target interaction event. A target interaction event is an interaction event generated when the user interacts with the user interface generated by the A2UI message rendering. For example, if the user interface is an organization registration form, the target interaction event generated by the user interacting with the organization registration form interface could be the interaction event of the user clicking the submit button on the organization registration form node. When a target interaction event occurs on the user interface, the client can transmit the interaction event information corresponding to the target interaction event to the A2UI agent. The A2UI agent can determine the target interaction event based on the interaction event information, and based on the target interaction event and the skill entry index file, retrieve the existing interaction event script corresponding to the interaction event from the existing interaction event script set and execute it, obtaining the execution result and feeding it back to the client, thus realizing the interaction function of the target interaction event. In some examples, the client can interact directly with the A2UI agent. In this case, the client can transmit the interaction event information of the target interaction event to the A2UI agent through the interface between the client and the A2UI agent, and the A2UI agent can feed back the execution result to the client through the interface between the client and the client. In other examples, the client can interact with the main agent that handles integrated business, and the main agent that handles integrated business interacts with the A2UI agent. The client can transmit the interaction event information of the target interaction event to the main agent, and the main agent then forwards the interaction event information of the target interaction event to the A2UI agent. The A2UI agent can provide feedback on the execution result to the main agent, and the main agent then provides feedback on the execution result to the client.

[0031] In this embodiment, in response to a user interface request, an A2UI agent for executing A2UI services can load an A2UI generation skill with A2UI message generation and interactive event handling capabilities. Based on the target business requirements corresponding to the user interface request, the skill entry index file included in the A2UI generation skill, and a first object, a target A2UI message conforming to the target business requirements is obtained. This allows the client to render the target A2UI message, generating and displaying the user interface to the user. When a target interactive event occurs in the user interface, the A2UI agent can execute the target interactive event script based on the target interactive event, all skill entry files included in the A2UI generation skill, and the existing set of interactive event scripts. The execution result is then fed back to the client, completing the interactive function of the target interactive event. The existing set of interactive event scripts in the A2UI generation skill includes pre-generated existing interactive event scripts, eliminating the need for hard-coding of the agent to execute interactive events. If the interactive requirements of the user interface need to be expanded, only the A2UI generation skill needs to be updated, without having to go through the entire development process of requirement determination, development, testing, and release again. This reduces the difficulty of expanding the interactive functions of the user interface corresponding to the A2UI message. Furthermore, during the process of expanding the existing interactive event scripts in the A2UI generated skills, the existing existing interactive event scripts in the skill entry index file, reference knowledge resource set, existing A2UI message set, and existing interactive event script set in the A2UI generated skills can all be used normally. The A2UI agent can still load the A2UI generated skills to provide services, which can ensure the stability of the A2UI agent in providing services.

[0032] In some embodiments, the skill entry index file includes an index of existing A2UI messages, which includes the correspondence between business requirements and existing A2UI messages in the collection of existing A2UI messages. Each index in the existing A2UI message index represents the correspondence between a business requirement and an existing A2UI message. For example, each index in the existing A2UI message index may include a description of the business requirement and the storage path of the existing A2UI message, and may also include, but is not limited to, one or more of the following: index number, message version, review status, and applicable scenario description; the A2UI message may be reviewed by an auditor, and the review status represents the status of the A2UI message being reviewed; the applicable scenario description describes the scenarios in which the A2UI message is applicable.

[0033] In some embodiments, if the existing A2UI message index includes business requirements that match the target business requirement, the existing A2UI message corresponding to the matching business requirement is retrieved from the existing A2UI message set as the target A2UI message based on the business requirements in the existing A2UI message index that match the target business requirement. The existence of a business requirement matching the target business requirement in the existing A2UI message index can be determined by comparing the similarity between the target business requirement and the business requirements in the existing A2UI message index. This comparison can be achieved by comparing the similarity between the description of the target business requirement and the description of the business requirements in the existing A2UI message index. If the similarity between the target business requirement and the business requirements in the existing A2UI message index is greater than or equal to a similarity threshold, it is determined that a business requirement matching the target business requirement exists in the existing A2UI message index; that is, a business requirement that is the same as or similar to the target business requirement exists in the existing A2UI message index. The similarity threshold can be set according to the scenario, requirements, experience, etc., and is not limited here. If there is only one business requirement in the existing A2UI message index that matches the target business requirement, then the existing A2UI message corresponding to this one business requirement will be used as the target A2UI message. If there are two or more business requirements in the existing A2UI message index that match the target business requirement, then the existing A2UI message corresponding to the business requirement with the highest similarity among the two or more business requirements will be used as the target A2UI message.

[0034] If the existing A2UI message index includes business requirements that match the target business requirements, it is not necessary to call the large model to generate A2UI messages. Instead, existing A2UI messages in the existing A2UI message set can be reused. On the one hand, this can reduce the consumption of token resources. On the other hand, it can also ensure that the same or similar business requirements can provide the same A2UI messages to the client, so as to ensure the consistency of A2UI messages for the same or similar business requirements.

[0035] In some embodiments, the skill entry index file may further include a resource index, which may be an index of a set of reference knowledge resources or an index of reference knowledge resources within that set. If the existing A2UI message index does not include business requirements matching the target business requirement, the A2UI agent extracts reference knowledge resources matching the target business requirement from the set of reference knowledge resources based on the target business requirement and the resource index. The A2UI agent then generates prompt words based on the extracted reference knowledge resources. Finally, the A2UI agent calls the large model to generate the target A2UI message based on the prompt words. If the similarity between the target business requirement and the business requirements in the existing A2UI message index is less than a similarity threshold, it is determined that there is no business requirement matching the target business requirement in the existing A2UI message index; that is, there is no business requirement identical or similar to the target business requirement in the existing A2UI message index, and the target business requirement is a new business requirement. In this case, the A2UI agent can index reference knowledge resources matching the target business requirement from the set of reference knowledge resources according to the target business requirement and the resource index, assemble prompt words, and achieve on-demand generation of prompt words. Input the prompt words into the large model. Guided by the prompt words, the large model can output A2UI messages. The target A2UI message can be obtained from the A2UI messages output by the large model. In some examples, the A2UI message output by the large model can be identified as the target A2UI message. In other examples, the A2UI message output by the large model can be further processed to obtain the target A2UI message.

[0036] By loading A2UI generated skills through the A2UI agent, when new types of business needs arise, reference knowledge resources in the reference knowledge resource set of A2UI generated skills can be loaded on demand to generate prompt words. This avoids the situation where there are too many prompt words and a large number of tokens are consumed to generate A2UI messages. The target A2UI message can be generated with fewer tokens, saving token resources.

[0037] In some embodiments, after the large model outputs an A2UI message, to ensure the completeness of the A2UI message and its adaptability to the business, the user interface corresponding to the A2UI message can be previewed and reviewed. Based on the review result, the final target A2UI message to be fed back to the client is determined. Specifically, the A2UI agent can call the large model to generate an initial A2UI message based on the prompt words; the A2UI agent can call the A2UI previewer to render the initial A2UI message, generate the user interface to be reviewed, and display it to the reviewer; if the reviewer indicates that the review has not passed, the A2UI message editor can be called to modify the initial A2UI message, or the prompt words input into the large model can be modified to update the initial A2UI message, until the user interface to be reviewed obtained by rendering the updated initial A2UI message passes the reviewer's review, and the updated initial A2UI message is determined as the target A2UI message.

[0038] The initial A2UI message is generated by the large model based on the prompt words. The A2UI agent calls the A2UI previewer, which renders the initial A2UI message to generate a user interface to be reviewed. This user interface is the interface generated by the A2UI previewer based on the initial A2UI message and is intended for review by the reviewer. The interface to be reviewed can be shown directly to the reviewer through the A2UI previewer, or a preview link of the user interface rendered by the A2UI previewer can be sent to the reviewer so that the reviewer can input data through the preview link and view the interface to be reviewed. The reviewer and the user who sent the user interface request can be the same user or different users; this is not limited. After reviewing the interface to be reviewed, the reviewer can input the review result, which is received by the A2UI agent. If the review result indicates that the review is passed, it means that the initial A2UI message is complete and meets the business requirements, and the initial A2UI message can be designated as the target A2UI message. If the review result indicates that the review failed, it means that the initial A2UI message is incomplete and / or does not meet business requirements, and the A2UI message needs to be corrected. In some examples, the A2UI message editor can be invoked to edit the A2UI message. For example, the initial A2UI message can be modified to update it based on the edit input received from the reviewer. In other examples, the prompts for the input model can also be modified. The modified prompts are then input into the model, and the model outputs an A2UI message based on the modified prompts. The newly output A2UI message is the updated initial A2UI message. After obtaining the updated initial A2UI message, the A2UI previewer can be called again to render the updated initial A2UI message to obtain a new user interface to be reviewed. This new user interface is then shown to the reviewer. This process continues until the new user interface to be reviewed passes the reviewer's approval. This indicates that the updated initial A2UI message corresponding to the new user interface to be reviewed is a complete A2UI message that meets the business requirements. The updated initial A2UI message is then identified as the target A2UI message.

[0039] By adding a preview and correction process for the user interface corresponding to the A2UI message to the intermediate layer between the A2UI agent and the user, it is ensured that the generated A2UI message is reviewed and meets the target business requirements, thereby ensuring the certainty and completeness of the target A2UI message fed back to the client.

[0040] In some embodiments, after the A2UI agent calls the large model to generate the target A2UI message based on the prompt words, a correspondence between the target business requirement and the target A2UI can be established, and the correspondence between the target business requirement and the target A2UI can be added to the existing A2UI message index; the target A2UI message can be added to the existing A2UI message set as an existing A2UI message. The target A2UI message generated by the large model based on the prompt words is a new type of A2UI message relative to the existing A2UI message set. The target A2UI message can be added as an existing A2UI message to the existing A2UI message set in the A2UI generation skill. The correspondence between the target A2UI message and the target business requirement is also added to the existing A2UI message index in the skill entry index file. This enables automatic updates to the existing A2UI message set and the existing A2UI message index. As a result, when a business requirement that is the same as or similar to the target business requirement reappears, the target A2UI message can be reused, shortening the time to obtain the target A2UI message, increasing the speed of user interface generation, and thus improving the user experience of obtaining the user interface using the A2UI agent.

[0041] In some embodiments, the skill entry index file includes an index of existing interaction event scripts, which includes the correspondence between interaction events and existing interaction event scripts in the collection of existing interaction event scripts. Each index in the existing interaction event script index represents the correspondence between an interaction event and an existing interaction event script. For example, each index in the existing interaction event script index may include an interaction event behavior description and the storage path of the existing interaction event script, and may also include, but is not limited to, one or more of the following: index number, script function description, and corresponding message scenario. The index must be the index number in the existing interaction event script index, the script function description describes the function of the existing interaction event script, and the corresponding message scenario is the usage scenario of the A2UI message on which the interaction event depends.

[0042] The A2UI agent can retrieve the corresponding existing event script from the existing event script collection based on the target interaction event and the existing event script index. This script is then executed, and the execution result is returned. Alternatively, the existing event script corresponding to the target interaction event can be located in the existing event script index, indexed to its storage location in the existing event script collection, retrieved, and identified as the target interaction event script. The A2UI agent executes this script, obtains the execution result, and returns it to the client, thus realizing the interactive function of the target interaction event.

[0043] In some embodiments, the A2UI agent can be used as a sub-agent of the main agent handling integrated services. This is equivalent to separating the A2UI message generation capability and the user interface interaction event handling capability from the main agent, and using the A2UI agent to generate A2UI messages and handle user interface interaction events. Users can interact directly with the main agent, which can receive user service requests input by the user. These user service requests are used by the user to request service. The main agent can parse the user service requests; in some examples, the user service request may be the same as the user interface request, and the main agent can forward the user service request (i.e., the user interface request) to the sub-agent; in other examples, the main agent can decompose the user service request into corresponding functional requests, including user interface requests. The main agent then assigns the user interface request to the A2UI agent, which performs subsequent processing.

[0044] For example, Figure 2 A logical schematic diagram of an example of an agent-based user interface processing method provided in an embodiment of this application, as shown below. Figure 2 As shown, user 21 can initiate a user service request to the main intelligent agent 22, which is a user interface request. The main intelligent agent 22 forwards the user interface request to the A2UI intelligent agent 23. The A2UI intelligent agent 23 loads the A2UI generated skill 24. The A2UI generated skill 24 includes a skill entry index file 241, a reference knowledge resource set 242, a set of existing A2UI messages 243, and a set of existing interactive event scripts 244. The skill entry index file 241 can be represented as SKILL.md, the reference knowledge resource set 242 can be represented as references / , the set of existing A2UI messages 243 can be represented as scripts / , and the set of existing interactive event scripts 244 can be represented as a2ui / . The A2UI intelligent agent 23 can call the A2UI previewer 25 and the A2UI editor 26. Users can interact with the A2UI previewer 25 and the A2UI editor 26 to review and correct the initial A2UI messages.

[0045] To facilitate understanding, the following example of a user applying for network access to an organization illustrates the process of the user interface processing method based on intelligent agents. Figure 3 A flowchart illustrating an example of an agent-based user interface processing method for network access scenarios provided in this application embodiment is shown below. Figure 3 As shown, the user interface processing method based on intelligent agents in the network access scenario of the applicant agency may include steps a1 to a22.

[0046] In step a1, the user initiates a user service request to the main intelligent agent, stating "I am XX organization, applying for organization network access".

[0047] In step a2, the main agent performs inference based on user business. The main agent's inference may include collecting the institutional information required for institutional network access and generating an institutional network access form.

[0048] In step a3, the main agent sends the organization's network access form to the A2UI agent. This organization's network access form can be considered as a user interface request in the above embodiments.

[0049] In step a4, the A2UI agent loads the A2UI generated skill.

[0050] In step a5, the A2UI agent obtains the skill entry index file. The skill entry index file can be the SKILL.md file in the above embodiment.

[0051] In step a6, the A2UI agent can determine whether there is an existing A2UI message index for the requirement of a structured network entry form in the skill entry index file. If there is an existing A2UI message index for the requirement of a structured network entry form, proceed to step a7; if there is no existing A2UI message index for the requirement of a structured network entry form, proceed to step a16.

[0052] In step a7, the A2UI agent sends the target A2UI message back to the main agent. The target A2UI message in step a7 is the existing A2UI message corresponding to the requirement of the structured network entry form, obtained from the existing A2UI message set, assuming there is an index of existing A2UI messages with a requirement for the structured network entry form.

[0053] In step a8, the main agent renders the target A2UI message and displays the user interface to the user so as to receive the information filled in by the user on the structure network entry form.

[0054] In step a9, the user interacts with the user interface to submit an organization registration form to the main agent. This submitted form is the one with the information filled in. Submitting the organization registration form is the user's target interaction event with the user interface.

[0055] In step a10, the main agent infers the target interaction event based on the submitted organization network access form.

[0056] In step a11, the main agent sends the target interaction event to the A2UI agent.

[0057] In step a12, the A2UI agent invokes A2UI to generate skills.

[0058] In step a13, the A2UI agent obtains the skill entry index file.

[0059] In step a14, the A2UI agent, based on the skill entry index file, determines and executes the existing interaction event script corresponding to the target interaction event, obtaining the execution result. This execution result is the submission result of the organization's network access form.

[0060] In step a15, the A2UI agent reports the execution result back to the main agent.

[0061] In step a16, the A2UI agent obtains reference knowledge resources corresponding to the target business requirements from the A2UI generated skills. These reference knowledge resources may include A2UI protocols, component catalog prompts, and business knowledge related to network structure integration.

[0062] In step a17, the A2UI agent invokes the large model to generate the target A2UI message based on the reference knowledge resources.

[0063] In step a18, the A2UI agent generates a preview link to notify the user for review. It should be noted that during the review process, the A2UI agent does not send A2UI messages back to the main agent.

[0064] In step a19, the user previews the user interface to be reviewed from the A2UI previewer via the A2UI preview link.

[0065] In step a20, the A2UI agent determines whether the review is approved. If the review is approved, step a21 is executed; if the review is not approved, step a22 is executed.

[0066] In step a21, the target A2UI message and the index of the existing A2UI message of the target A2UI message are stored in the A2UI generation skill.

[0067] In step a22, the A2UI agent can refine the A2UI message, regenerate the A2UI message, or reject the user interface request. Refining the A2UI message can be achieved by correcting the A2UI message using the A2UI editor, or by modifying the target business requirements.

[0068] The specific details of steps a1 to a22 above can be found in the relevant descriptions in the above embodiments, and will not be repeated here.

[0069] This application also provides an agent-based user interface processing apparatus, which corresponds to the agent-based user interface processing method in the above embodiments. Figure 4 This is a schematic diagram of the structure of a user interface processing device based on an intelligent agent provided in an embodiment of this application, as shown below. Figure 4 As shown, the agent-based user interface processing device 300 may include a skill loading module 301, an A2UI message generation module 302, and a script processing module 303.

[0070] The skill loading module 301 can be used to load A2UI generated skills through the A2UI agent in response to user interface requests. The A2UI generated skills include a skill entry index file, a set of reference knowledge resources, a set of existing A2UI messages, and a set of existing interactive event scripts. The skill entry index file is used to guide the A2UI agent to use the A2UI generated skills.

[0071] The A2UI message generation module 302 can be used to obtain the target A2UI message corresponding to the target business requirement based on the target business requirement, skill entry index file and first object corresponding to the user interface request. The first object includes one of the reference knowledge resource set and the existing A2UI message set. The target A2UI message is transmitted to the client for rendering to generate the user interface.

[0072] The script processing module 303 can be used to obtain and execute the target interaction event script based on the target interaction event that occurs in the user interface, the skill entry index file, and the existing interaction event script set through the A2UI intelligent agent, and then feed back the execution result to the client.

[0073] In some embodiments, the skill entry index file includes an index of existing A2UI messages, which includes the correspondence between business requirements and existing A2UI messages in the set of existing A2UI messages.

[0074] In some embodiments, the A2UI message generation module 302 can be used to: when the existing A2UI message index includes a business requirement that matches the target business requirement, obtain the existing A2UI message corresponding to the matching business requirement from the existing A2UI message set as the target A2UI message based on the business requirement that matches the target business requirement in the existing A2UI message index.

[0075] In some embodiments, the skill entry index file further includes a resource index, which is an index of reference knowledge resources in the reference knowledge resource set. The A2UI message generation module 302 can be used to: extract reference knowledge resources matching the target business requirements from the reference knowledge resource set based on the target business requirements and the resource index, when the existing A2UI message index does not include such business requirements; generate prompt words based on the extracted reference knowledge resources; and generate the target A2UI message by calling the large model based on the prompt words.

[0076] In some embodiments, the agent-based user interface processing device 300 may further include an update module, which is configured to: after generating a target A2UI message by calling a large model through an A2UI agent based on prompt words, establish a correspondence between the target business requirement and the target A2UI, and add the correspondence between the target business requirement and the target A2UI to the existing A2UI message index; and add the target A2UI message as an existing A2UI message to the existing A2UI message set.

[0077] In some embodiments, the A2UI message generation module 302 can be used to: call the large model through the A2UI agent to generate an initial A2UI message based on the prompt words; call the A2UI previewer through the A2UI agent to render the initial A2UI message, generate a user interface to be reviewed, and display it to the reviewer; if the reviewer indicates that the review has not passed, call the A2UI message editor to modify the initial A2UI message, or modify the prompt words of the input large model to update the initial A2UI message, until the user interface to be reviewed obtained by rendering the updated initial A2UI message passes the reviewer's review, and determine the updated initial A2UI message as the target A2UI message.

[0078] In some embodiments, the skill entry index file includes an index of existing interaction event scripts, which includes the correspondence between interaction events and existing interaction event scripts in the existing interaction event script set. The script processing module 303 can be used to: obtain, through the A2UI agent, the existing event script corresponding to the target interaction event from the existing interaction event script set as the target interaction event script based on the target interaction event and the existing interaction event script index; execute the target interaction event script and provide feedback on the execution result.

[0079] In some embodiments, the agent-based user interface processing device 300 may further include a master agent communication module, which may be used to: receive user service requests through the master agent, parse the user service requests to obtain user interface requests, and send user interface requests to the A2UI agent through the master agent.

[0080] It should be noted that the intelligent agent-based user interface processing device 300 is a device corresponding to the above-described method for accessing virtual reality conferences. All implementation methods in the above method embodiments are applicable to the embodiments of this device and can achieve the same technical effect.

[0081] This application also provides an electronic device. Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application, as shown below. Figure 5As shown, the electronic device 400 includes a memory 401, a processor 402, and a computer program stored in the memory 401 and executable on the processor 402.

[0082] In some examples, the processor 402 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.

[0083] Memory 401 may include read-only memory (ROM), random access memory (RAM), disk storage media device, optical storage media device, flash memory device, electrical, optical, or other physical / tangible memory storage device. 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 user interface processing method according to embodiments of this application.

[0084] The processor 402 runs a computer program corresponding to the executable program code by reading the executable program code stored in the memory 401, so as to implement the agent-based user interface processing method in the above embodiments.

[0085] In some examples, electronic device 400 may also include a communication interface 403 and a bus 404. For example, Figure 5 As shown, the memory 401, processor 402, and communication interface 403 are connected through bus 404 and complete communication with each other.

[0086] The communication interface 403 is mainly used to realize 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 403.

[0087] Bus 404 includes hardware, software, or both, that couples components of electronic device 400 together. For example, and not as a limitation, bus 404 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 404 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.

[0088] 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 user interface processing 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.

[0089] 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 user interface processing method in the above embodiments and can achieve the same technical effect. To avoid repetition, it will not be described again here.

[0090] 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 the device embodiments, equipment embodiments, computer-readable storage medium embodiments, and computer program product embodiments, the 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.

[0091] 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.

[0092] 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 user interface processing method based on intelligent agents, characterized in that, include: In response to a user interface request, an A2UI generated skill is loaded through the A2UI agent. The A2UI generated skill includes a skill entry index file, a set of reference knowledge resources, a set of existing A2UI messages, and a set of existing interactive event scripts. The skill entry index file is used to guide the A2UI agent in using the A2UI generated skill. Based on the target business requirement corresponding to the user interface request, the skill entry index file, and the first object, the target A2UI message corresponding to the target business requirement is obtained. The first object includes one of the reference knowledge resource set and the existing A2UI message set. The target A2UI message is transmitted to the client for rendering to generate the user interface. The A2UI agent obtains and executes the target interaction event script based on the target interaction event occurring in the user interface, the skill entry index file, and the existing set of interaction event scripts, and then sends the execution result back to the client.

2. The method according to claim 1, characterized in that, The skill entry index file includes an index of existing A2UI messages, which includes the correspondence between business requirements and existing A2UI messages in the set of existing A2UI messages.

3. The method according to claim 2, characterized in that, The process of obtaining the target A2UI message corresponding to the target business requirement based on the user interface request, the skill entry index file, and the first object includes: If the existing A2UI message index includes a business requirement that matches the target business requirement, the existing A2UI message corresponding to the matching business requirement is obtained from the existing A2UI message set as the target A2UI message, based on the business requirement that matches the target business requirement in the existing A2UI message index.

4. The method according to claim 2, characterized in that, The skill entry index file also includes a resource index, which is an index of reference knowledge resources in the reference knowledge resource set; The process of obtaining the target A2UI message corresponding to the target business requirement based on the user interface request, the skill entry index file, and the first object includes: If the existing A2UI message index does not include business requirements that match the target business requirements, the A2UI agent extracts reference knowledge resources that match the target business requirements from the reference knowledge resource set based on the target business requirements and the resource index. The A2UI intelligent agent generates prompt words based on extracted reference knowledge resources; The A2UI agent invokes the large model to generate the target A2UI message based on the prompt words.

5. The method according to claim 4, characterized in that, After the A2UI agent invokes the large model to generate the target A2UI message based on the prompt word, the method further includes: Establish the correspondence between the target business requirements and the target A2UI, and add the correspondence between the target business requirements and the target A2UI to the existing A2UI message index; The target A2UI message is added to the existing A2UI message set as an existing A2UI message.

6. The method according to claim 4, characterized in that, The step of invoking the large model through the A2UI agent to generate the target A2UI message based on the prompt words includes: The A2UI agent invokes the large model to generate an initial A2UI message based on the prompt words; The A2UI agent calls the A2UI previewer to render the initial A2UI message, generates a user interface to be reviewed, and displays it to the reviewer. If the reviewer receives a review result indicating that the representation has not passed the review, the A2UI message editor is invoked to modify the initial A2UI message, or the prompt words of the input large model are modified to update the initial A2UI message, until the user interface to be reviewed rendered by the updated initial A2UI message passes the reviewer's review, and the updated initial A2UI message is determined as the target A2UI message.

7. The method according to claim 1, characterized in that, The skill entry index file includes an index of existing interactive event scripts, which includes the correspondence between interactive events and existing interactive event scripts in the set of existing interactive event scripts. The process of obtaining and executing a target interaction event script through the A2UI intelligent agent based on the target interaction event occurring in the user interface, the skill entry index file, and the existing set of interaction event scripts, and then feeding back the execution result to the client, includes: The A2UI agent retrieves the existing event script corresponding to the target interaction event from the existing interaction event script set based on the target interaction event and the existing interaction event script index, and uses it as the target interaction event script. Execute the target interactive event script and report the execution result.

8. The method according to claim 1, characterized in that, Also includes: The main intelligent agent receives user service requests, parses the user service requests, and obtains user interface requests. The main agent sends the user interface request to the A2UI agent.

9. A user interface processing device based on an intelligent agent, characterized in that, include: The skill loading module is used to load A2UI generated skills through the A2UI agent in response to user interface requests. The A2UI generated skills include a skill entry index file, a reference knowledge resource set, a set of existing A2UI messages, and a set of existing interactive event scripts. The skill entry index file is used to guide the A2UI agent to use the A2UI generated skills. The A2UI message generation module is used to obtain the target A2UI message corresponding to the target business requirement based on the target business requirement corresponding to the user interface request, the skill entry index file, and the first object. The first object includes one of the reference knowledge resource set and the existing A2UI message set. The target A2UI message is transmitted to the client for rendering to generate the user interface. The script processing module is used to obtain the target interaction event script through the A2UI intelligent agent based on the target interaction event occurring in the user interface, the skill entry index file, and the existing interaction event script set, and execute it, and then return the execution result to the client.

10. An electronic device, characterized in that, include: Processor and memory storing computer program instructions; When the processor executes the computer program instructions, it implements the agent-based user interface processing method as described in any one of claims 1 to 8.

11. 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 user interface processing method as described in any one of claims 1 to 8.

12. A computer program product, characterized in that, It includes a computer program that, when executed by a processor, implements the agent-based user interface processing method according to any one of claims 1 to 8.

Images