Interactive interface generation method and system, storage medium and program product

Abstract

The embodiment of the invention provides an interactive interface generation method and system, a storage medium and a program product, and relates to the technical field of artificial intelligence. The method comprises the steps of obtaining input task information which is triggered by a user and corresponds to a target interaction scene; obtaining a target response information block output by the agent corresponding to the target interaction scene for the input task information, wherein the target response information block is any one of a plurality of response information blocks output by the agent in a streaming manner; determining a target UI component corresponding to the target response information block in a UI component set corresponding to the target interaction scene; determining target rendering content corresponding to the target response information block through the application server, wherein the target rendering content is a semantic processing result of the target response information block; and filling the target UI component with the target rendering content so as to render the target UI component in an application interface of the application server. The scheme can reduce the cognitive load of the user and improve the user experience.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to an interactive interface generation method, system, storage medium, and program product. Background Technology

[0002] With the rapid development of artificial intelligence technology, intelligent agents are being widely applied in various fields such as e-commerce and content generation. Especially in e-commerce scenarios, users expect to interact with the system through natural language, images, and other means to complete complex tasks such as product search, price comparison, recommendations, and intelligent purchasing. This requires the system to understand user intent, invoke intelligent agents for corresponding processing, and transform the complex and unstructured information flow output by the intelligent agents into an interactive interface that users can understand and interact with.

[0003] In existing technologies, the internal execution processes of an agent during task execution (such as fine-grained events like before tool invocation, during tool parameter generation, and after tool execution) are typically sent and rendered in full on the front-end interactive interface. However, this approach is equivalent to exposing too many low-level system implementation details (such as tool invocation and parameter passing) to the user through the interactive interface, increasing the user's cognitive load and resulting in a poor user experience. Summary of the Invention

[0004] This application provides an interactive interface generation method, device, storage medium, and program product to reduce the cognitive load on users and improve user experience.

[0005] In a first aspect, embodiments of this application provide a method for generating an interactive interface, the method comprising: Obtain the input task information triggered by the user corresponding to the target interaction scenario; Obtain the target response information block output by the intelligent agent corresponding to the target interaction scenario in response to the input task information, wherein the target response information block is any one of the multiple response information blocks streamed by the intelligent agent; In the set of UI components corresponding to the target interaction scenario, determine the target UI component corresponding to the target response information block; The target rendering content corresponding to the target response information block is determined by the application server, and the target rendering content is the semantic processing result of the target response information block; The target rendering content is filled into the target UI component so that the target UI component is rendered in the application interface of the application server.

[0006] Secondly, embodiments of this application provide an interactive interface generation apparatus, the apparatus comprising: The acquisition module is used to acquire input task information triggered by the user and corresponding to the target interaction scenario; and to acquire the target response information block output by the intelligent agent corresponding to the target interaction scenario in response to the input task information, wherein the target response information block is any one of multiple response information blocks streamed by the intelligent agent; The determination module is used to determine the target UI component corresponding to the target response information block in the set of UI components corresponding to the target interaction scenario; and to determine the target rendering content corresponding to the target response information block through the application server, wherein the target rendering content is the semantic processing result of the target response information block; The rendering module is used to fill the target UI component with the target rendering content so as to render the target UI component in the application interface of the application server.

[0007] Thirdly, embodiments of this application provide an interactive interface generation system, the system comprising: a central control subsystem, an intelligent agent, and an application server; the central control subsystem comprising: a rendering client and an interaction engine; The interaction engine is used to acquire input task information triggered by the user corresponding to the target interaction scenario; acquire the target response information block output by the agent corresponding to the target interaction scenario in response to the input task information; determine the target UI component corresponding to the target response information block in the UI component set corresponding to the target interaction scenario; determine the target rendering content corresponding to the target response information block through the application server; and send the target rendering content and the target UI component to the rendering client, wherein the target response information block is any one of multiple response information blocks streamed by the agent, and the target rendering content is the semantic processing result of the target response information block; The application server is used to determine the target rendering content based on the target response information block; The rendering client is used to populate the target UI component with the target rendering content so as to render the target UI component in the application interface of the application server.

[0008] Fourthly, embodiments of this application provide an electronic device, including: a memory, a processor, and a communication interface; wherein, the memory stores executable code, and when the executable code is executed by the processor, the processor executes the interactive interface generation method as described in the first aspect.

[0009] Fifthly, embodiments of this application provide a non-transitory machine-readable storage medium storing executable code, which, when executed by a processor of an electronic device, enables the processor to at least implement the interactive interface generation method as described in the first aspect.

[0010] Sixthly, embodiments of this application provide a computer program product, the computer program product including a computer program, which, when executed by a processor, can implement the interactive interface generation method as described in the first aspect.

[0011] In the interactive interface generation scheme provided in this application embodiment, firstly, the input task information triggered by the user and corresponding to the target interaction scenario is obtained, and the intelligent agent corresponding to the target interaction scenario is guided to process the input task information to obtain the target response information block output by the intelligent agent in response to the input task information. The target response information block can be understood as the raw data unit generated by the intelligent agent, which contains or is associated with the underlying implementation details.

[0012] It's important to note that in practical applications, this target response information block is not directly presented to the user. Instead, it is sent to the application server, which performs semantic processing to convert the technical language output by the intelligent agent into a user-facing service language. This user-facing service language is then populated into the target UI component corresponding to the target response information block, and rendered on the application server's interface. This ensures that the user sees a complete, easy-to-understand service information interface that is more relevant to the interaction scenario, without being exposed to the detailed underlying implementation details of the intelligent agent. This reduces the user's cognitive load and provides a better user experience. Attached Figure Description

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

[0014] Figure 1 This is a schematic diagram of the structure of an interactive interface generation system provided in an embodiment of this application; Figure 2 A flowchart illustrating an interactive interface generation method provided in this application embodiment; Figure 3 A schematic diagram illustrating the mapping relationship between a response information block and a UI component, provided for an embodiment of this application; Figure 4 Another flowchart of an interactive interface generation method provided in this application embodiment; Figure 5 An overall flowchart of a session interruption resumption method is provided in an embodiment of this application; Figure 6 This is an application diagram illustrating a mapping relationship configuration provided in an embodiment of this application; Figure 7 A schematic diagram illustrating the application of an interactive interface generation method provided in this application embodiment; Figure 8 This is a schematic diagram of the structure of an interactive interface generation device provided in an embodiment of this application; Figure 9 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0015] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application. In addition, the timing of the steps in the following method embodiments is only an example and not a strict limitation.

[0016] It should be noted that, in the cases involving user information in the embodiments of this application, the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in the embodiments of this application are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use, and processing of related data must comply with the relevant laws, regulations, and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse. In addition, the various models involved in this application (including but not limited to large language models or other models) comply with relevant laws and standards.

[0017] Additionally, it should be noted that the various functional models involved in the embodiments of this application can be language models (LM) or multimodal models (MM) based on artificial intelligence. The embodiments of this application do not limit the number of model parameters supported by the model, aiming to meet actual needs. If the model has relatively more parameters, the model will be relatively larger in scale and have relatively better performance; however, it will consume more time and resources during inference or training. If the model has relatively fewer parameters, the model will be relatively smaller in scale, and while meeting performance requirements, it will be more lightweight, consuming less time and resources during inference or training. The aforementioned model can be a deep learning model used to process and generate natural language text or multimodal data, and can be implemented based on a neural network architecture, which can be pre-trained on large amounts of data. In an optional implementation, the aforementioned model can include an encoder, a decoder, a self-attention layer, and a feed-forward neural network, etc. The encoder is mainly used to convert input data (usually in sequence form) into vector representation. This process can capture the semantic features of the input data. The decoder is responsible for converting the intermediate representation generated by the encoder into output data (usually in sequence form). The self-attention layer is a mechanism that allows the model to pay attention to other positions in the sequence to better encode the current position information. The feedforward neural network can perform nonlinear transformations on the output of the self-attention layer to enhance the model's expressive power. All parts work together, enabling the model built on them to perform well in various complex processing tasks, such as natural language processing, computer vision, speech recognition, machine translation, text summarization, and intelligent question answering.

[0018] The following explains the terms or concepts involved in the embodiments of this application: An agent is an intelligent proxy system that uses the language model mentioned above as its core controller. Essentially, it is an agent system that controls the language model to solve user problems. It relies on the language model as its core decision-making and processing unit and can use the logical reasoning ability of the language model to break down the solution steps of the user problem, call tools, and summarize the solution results of multiple steps.

[0019] User Interface Component (UI): A reusable interface element unit with specific functions and visual presentation in a user interface.

[0020] Streaming rendering: a data processing and UI component update mode that allows content to be rendered incrementally before complete data is received, thereby significantly improving the perceived responsiveness to the user.

[0021] Currently, rendering the internal execution process of an intelligent agent during task execution onto the front-end interactive interface exposes users to too many underlying system implementation details (such as tool calls and parameter passing), increasing the user's cognitive load and resulting in a poor user experience.

[0022] In view of this, this application provides an interactive interface generation method that solves the above problems through the following approach: After obtaining the input task information triggered by the user, the intelligent agent is guided to output a response information block, rather than a streaming full execution event, laying the foundation for avoiding the subsequent display of detailed underlying implementation details to the user. Then, the application server performs semantic processing on the response information block, and the semantically processed rendering content is rendered and presented to the user by the UI component corresponding to the response information block. This allows the user to see a complete and easy-to-understand service information interface without seeing the underlying implementation details of the intelligent agent, reducing the user's cognitive load and providing a better user experience.

[0023] To facilitate understanding of the overall architecture of this solution, a brief introduction will first be given to an interactive interface generation system provided in the embodiments of this application. Figure 1 This is a schematic diagram of the structure of an interactive interface generation system provided in an embodiment of this application, such as... Figure 1 As shown, the interactive interface generation system includes a central control subsystem, an intelligent agent, and an application server. The central control subsystem includes a rendering client and an interaction engine. The interaction engine is used to acquire user-triggered input task information corresponding to the target interaction scenario; acquire the target response information block output by the intelligent agent in response to the input task information; determine the target UI component corresponding to the target response information block from the UI component set corresponding to the target interaction scenario; determine the target rendering content corresponding to the target response information block through the application server; and send the target rendering content and the target UI component to the rendering client. The target response information block is any one of multiple response information blocks streamed by the intelligent agent, and the target rendering content is the semantic processing result of the target response information block. The application server determines the target rendering content based on the target response information block. The rendering client fills the target UI component with the target rendering content to render the target UI component in the application interface of the application server.

[0024] In specific implementation, firstly, the user-triggered input task information corresponding to the target interaction scenario is obtained through the interaction engine, as well as the target response information block output by the intelligent agent corresponding to the target interaction scenario in response to the input task information. In the UI component set corresponding to the target interaction scenario, the target UI component corresponding to the target response information block is determined. The target response information block is any one of multiple response information blocks streamed by the intelligent agent.

[0025] The interaction engine then sends the target response information block to the application server. Upon receiving the target response information, the application server determines the target rendering content based on the target response information block, where the target rendering content is the semantic processing result of the target response information block.

[0026] Next, the application server sends the target rendering content to the interaction engine. Upon receiving the target rendering content, the interaction engine sends the target rendering content and the target UI component to the rendering client. The rendering client, upon receiving the target rendering content and the target UI component, populates the target UI component with the target rendering content to render the target UI component in the application interface on the application server. It should be noted that, to save development resources and improve data loading speed, UI components can be reused in different interaction scenarios. For example, assuming both scenario A and scenario B are product shopping scenarios, they can reuse UI components such as the "product list search component" and the "product details display component."

[0027] For details on the implementation of this interactive interface generation system in practical applications, please refer to the following embodiments, which will not be described in detail here.

[0028] Figure 2 This is a flowchart illustrating an interactive interface generation method provided in an embodiment of this application. This method can be applied to the aforementioned interactive interface generation system, such as... Figure 2 As shown, the method includes the following steps: 201. Obtain the input task information triggered by the user that corresponds to the target interaction scenario.

[0029] 202. Obtain the target response information block output by the agent in response to the input task information corresponding to the target interaction scenario. The target response information block is any one of the multiple response information blocks streamed by the agent.

[0030] 203. In the set of UI components corresponding to the target interaction scenario, determine the target UI component corresponding to the target response information block.

[0031] 204. Determine the target rendering content corresponding to the target response information block through the application server. The target rendering content is the semantic processing result of the target response information block.

[0032] 205. Populate the target UI component with the target rendering content to render the target UI component in the application interface on the application server.

[0033] In practical applications, the first step is to obtain the input task information triggered by the user and corresponding to the target interaction scenario. Specifically: One implementation approach is to pre-configure a scenario library, which contains a one-to-one mapping between interactive scenarios and scenario identifiers. In practical applications, when a user triggers a task request (such as "find similar products to the current product") on the application's interface, this task request carries a target scenario identifier. Upon receiving this task request, the interaction engine determines the target interactive scenario (such as the "choose similar products" scenario) corresponding to the target scenario identifier, based on the one-to-one mapping between interactive scenarios and scenario identifiers. At this point, the interaction engine obtains the input task information triggered by the user corresponding to the target interactive scenario.

[0034] As another implementation method, a task request triggered by the user is received, which carries input task information; the input task information is subjected to interaction scenario intent recognition to obtain intent recognition results; and the target interaction scenario is determined among multiple interaction scenarios based on the intent recognition results.

[0035] In practice, the user triggers a task request on the application's interface, which is then sent to the interaction engine via a Software Development Kit (SDK). This task request carries input task information. The application's interface can be a product search screen in a shopping application, a question-and-answer dialogue interface in a question-and-answer application, and so on, without being listed here. The input task information can also take various forms, such as text, images, and voice, without limitation.

[0036] After receiving the task request, the interaction engine invokes the intent recognition service (which can be integrated into the interface generation system or interface with an externally configured service) to perform interaction scenario intent recognition on the input task information carried in the task request, obtaining the intent recognition result. For example, assuming the input task information is "Help me find a dress similar to this one," the intent recognition result after performing interaction scenario intent recognition on this input task information could be "Find the same style"; while assuming the input task information is "Help me compare the differences between these three mobile phones," the intent recognition result after performing interaction scenario intent recognition on this input task information could be "Product comparison." It should be noted that the interface generation system has a pre-configured scenario library, which contains multiple interaction scenarios, each bound to one or more intent tags. In practical applications, when the intent recognition result is obtained, it can be matched with one or more intent tags. If the match is successful, the target interaction scenario can be determined. For example, assuming the intent tag corresponding to the "choose the same style scenario" is "choose the same style," then when the intent recognition result is "find the same style," the "choose the same style scenario" can be successfully matched.

[0037] By performing interaction scenario intent recognition on the input task information, the target interaction scenario can be automatically identified from multiple interaction scenarios. This ensures the accuracy of the identified target interaction scenario and lays the foundation for subsequently finding a suitable intelligent agent to process the input task information. Furthermore, the entire process is fully automated; users do not need to manually select the interaction scenario, thus improving the user experience.

[0038] After obtaining the input task information corresponding to the target interaction scenario through at least two of the above implementation methods, the interaction engine inputs the input task information into the agent corresponding to the target interaction scenario, thereby obtaining multiple response information blocks (also known as AI Trunks) streamed by the agent. The target response information block currently being processed is any one of these multiple response information blocks. Each response information block represents an information unit, such as "thinking process" or "search results". For ease of understanding, the following example is provided: Suppose the input task information is "Help me find a dress similar to this one", and the target interaction scenario is "choose the same style". Then, after inputting the input task information into the agent, the multiple response information blocks output by the agent can be: Response Information Block 1: Thinking Process. For example, "Identifying style features in the image and matching similar products..."

[0039] Response information block 2: Search results. For example, "List of product IDs [A001, B002, C003]".

[0040] Response information block 3: Summary text. For example, "We have found 3 similar products for you."

[0041] Then, based on the user's characteristic information and / or the characteristic information of the application corresponding to the application interface, the set of UI components corresponding to the target interaction scenario is determined.

[0042] In practical applications, user characteristic information (such as username, user group, historical behavior, etc.) and / or application characteristic information corresponding to the application interface (such as application version, operating system, device type, etc.) can be obtained first. Then, based on this characteristic information and combined with preset rules (such as A / B experiment configuration, canary release rules, etc.), it is determined which UI components should be used in the current target interaction scenario, as well as the specific versions or styles of these UI components. These UI components constitute the UI component set corresponding to the target interaction scenario.

[0043] A / B testing is a scientific comparative experiment method that randomly divides users into different experimental groups, showcasing different versions of UI components or functions to each group. User behavior data is then collected, and key performance indicators (KPIs) are compared to determine which version performs better. Canary release, on the other hand, is a strategy for gradually releasing new features. It pushes new features to a subset of users in a real-world environment to test their stability and user feedback, while mitigating the risks of a full release. The specific implementation details of A / B testing and canary release rules are not the focus of this solution and will not be described in detail here. However, it's important to note that A / B testing and canary release rules can be used independently or in combination. When used together, A / B testing can be conducted simultaneously during the canary release of a new UI component to compare the effects of the old and new components. Alternatively, A / B testing can continue after the full release of the new UI component to optimize its details.

[0044] By determining the set of UI components corresponding to the target interaction scenario based on user characteristics and / or the characteristics of the application corresponding to the application interface, different users can see an interactive interface more suitable for them, achieving a personalized user experience. Furthermore, in practical applications, only the UI component resources needed by the current user need to be loaded, without loading other UI component resources that other users do not need, thus reducing the consumption of computing resources.

[0045] Next, within the set of UI components corresponding to the target interaction scenario, the target UI component corresponding to the target response information block is determined, specifically: One implementation method is to pre-configure matching rules. After obtaining the target response information block, the target UI component corresponding to the target response information block is determined based on the content characteristics of the target response information block according to the matching rules.

[0046] In practical implementation, for example, after obtaining the target response information block, the content of the target response information block is parsed. Suppose it contains the following content: "Identifying women's clothing styles in the image: round neck, three-quarter sleeves, floral pattern, chiffon fabric... 3 key features have been matched." Feature extraction is performed on this content, such as: The target response block should be approximately 50 characters long. User type: New user; User device: mobile phone.

[0047] Assuming the current matching rules are: if the user's device is a mobile phone and the content length is less than 100 characters, then the "Compact Thinking Display Frame Component" is used; if the user type is "New User," then the component needs to include a new user guide. Therefore, the final target UI component is the aforementioned "Compact Thinking Display Frame Component," which, after rendering, can look like this: a small thinking bubble displaying the message "Currently analyzing the clothing styles in your image... (This is your first time using this service; I will do my best to find similar products for you)."

[0048] As another implementation method, the type identifier corresponding to the target response information block can be obtained; based on the pre-configured mapping relationship between the response information block type identifier and the UI component, the target UI component corresponding to the type identifier of the target response information block can be determined in the set of UI components corresponding to the target interaction scenario.

[0049] It should be noted that, in order to distinguish different types of information units, the intelligent agent includes a type identifier (such as "thinking process," "search result," or "tool call result") in each response information block it outputs. In specific implementation, after obtaining the type identifier corresponding to the target response information block, the target UI component corresponding to the type identifier of the target response information block can be determined from the set of UI components corresponding to the target interaction scenario, based on the pre-configured mapping relationship between response information block type identifiers and UI components. For ease of understanding, for example, assuming the type identifier is "thinking process," then based on the above pre-configured mapping relationship, the target UI component corresponding to this type identifier can be determined to be a "thinking chain display box component." And assuming the type identifier is "search result," then based on the above pre-configured mapping relationship, the target UI component corresponding to this type identifier can be determined to be a "product card list component."

[0050] By obtaining the type identifier corresponding to the target response information block, the target UI component can be quickly identified in the set of UI components corresponding to the target interaction scenario based on the pre-configured mapping relationship between the response information block type identifier and UI components. This operation is simple and improves work efficiency.

[0051] Next, the application server determines the target rendering content corresponding to the target response information block. The target rendering content is the semantic processing result of the target response information block. In specific implementation: One implementation method is to identify the service data identifier that is missing service data in the target response information block; obtain the service data corresponding to the service data identifier from the application server, and the target rendering content includes the service data.

[0052] It's important to note that when the interaction engine receives the response information block from the agent, it needs to analyze which service data is contained within this block and what missing service data needs to be supplemented to meet the rendering requirements of the UI component. Rendering UI components typically requires a complete data structure, while the agent may output only partial data (such as only the product name). The service data identifier for missing service data can be understood as a key that uniquely identifies the required service data. For example, the product name is the service data identifier for retrieving product details. Subsequently, finding the value corresponding to the key in the application server completes the supplementation of the missing service data.

[0053] To make it easier to understand, the following example is provided: Suppose that in a "choose the same item" scenario, the agent outputs a target response information block containing three products, each with only its name provided. However, rendering the target UI component (such as a product card) requires more information, such as product images, prices, minimum order quantities, supplier qualifications, and delivery time. Therefore, after performing a recognition operation, the interaction engine can determine that the following service data identifiers are missing from each product's data: Product details service identifier: Product details (images, prices, etc.) can be obtained from the application server by using the product name; Supplier service identifier: Supplier qualification information can be obtained from the application server by using the product name; Logistics service identifier: Delivery time information can be obtained from the application server by using the product name.

[0054] For the aforementioned identification operations, for example, the data structure of the target response information block output by the intelligent agent can be compared with the data template of the target UI component to identify missing fields (e.g., missing product images, prices, and other attribute information), thereby determining the corresponding service data identifier; or, based on the type of the target response information block, it can be inferred which fields need service data completion, thereby determining the service data identifier corresponding to that field; or, based on the interaction scenario, it can be predefined which fields need service data completion (e.g., in a product comparison scenario, some product analysis data, such as a product analysis table, needs to be provided), thereby determining the service data identifier corresponding to that field, and so on, etc., which will not be listed here.

[0055] Next, the interaction engine sends a request to the corresponding application server based on the service data identifier to obtain complete data. This application server may include product services, supplier services, logistics services, etc. In practice, the interaction engine can call the batch query interface of the product service based on the product name to obtain the image, price, description, etc., of each product. It can also call the supplier service to obtain the qualifications of the supplier corresponding to each product (such as credit rating, factory size, etc.). Additionally, it can call the logistics service to obtain the delivery timeframe for each product (e.g., delivery within 48 hours). These services can be completed through a single combined request or through multiple requests called sequentially; there is no limitation on this, as long as the service data required for rendering the target UI component can be obtained smoothly and completely. Finally, this service data is integrated into the target rendering content.

[0056] By identifying the service data identifiers of missing service data in the target response information block and obtaining the service data corresponding to the service data identifiers from the application server, it can be ensured that the service data used by the target UI components is up-to-date and complete, guaranteeing the accuracy of the data displayed to the user and improving the user experience.

[0057] As another implementation method: According to the set information block semantic merging rules, if the target response information block is determined to be one of at least one response information block that needs to be semantically merged, the target response information block is sent to the application server; the merged semantic information output by the application server according to the information block semantic merging rules is received, and the target rendering content includes the merged semantic information.

[0058] In practical applications, based on the defined semantic merging rules for information blocks, it can be determined whether the target response information block belongs to at least one response information block that needs to be semantically merged. If so, the target response information block is sent to the application server (either after accumulating a certain number of response information blocks or in real time). After receiving the target response information block, the application server merges the received response information blocks according to the semantic merging rules, outputs the merged semantic information, and returns the merged semantic information to the interaction engine.

[0059] It should be noted that the above semantic merging occurs in at least the following cases: 1. Merge different response information blocks corresponding to the same processing procedure output successively by the same agent. For example, if an agent outputs multiple steps of a complex reasoning process in multiple parts, merge them into a complete reasoning summary.

[0060] 2. Merge response information blocks output by different agents for the same processing procedure. For example, multiple agents search from different databases and then merge them into a single comprehensive search result.

[0061] In addition, the semantic merge may be a summary of the detailed description of a response information block (i.e., compressed and refined), or it may be a semantic merge of multiple response information blocks (i.e., integrating the contents of multiple response information blocks).

[0062] To make it easier to understand, the following example is provided: In a "choose the same item" scenario, the agent might output a chain of thought (CoT) in multiple steps during the thought process, with each step representing a block of response information. For example: Response information block 1: Analyzing style features in the image; Response information block 2: Matching similar products; Response information block 3: Screening for qualified suppliers; Response information block 4: Generating recommendation reasons.

[0063] The semantic merging rule for information blocks is as follows: when all response information blocks corresponding to the steps of the same thought process are received, they are merged to generate a short summary of the thought process.

[0064] The merged semantic information can be interpreted as "Recommendations have been generated for you through steps such as analyzing image styles, matching similar products, and filtering suppliers."

[0065] By semantically merging multiple response information blocks according to the established information block semantic merging rules, these blocks can be integrated into more valuable comprehensive information, helping users make decisions faster. Furthermore, from the user's perspective, they will only see more concise and complete information, rather than fragmented, repetitive, or overly detailed process information, thus improving the user experience.

[0066] As another implementation: if there are multiple target UI components corresponding to the target response information block, the target response information block is sent to the application server for semantic decomposition; the target rendering content includes multiple decomposed semantic information output by the application server.

[0067] In practical applications, when the target response information block output by the intelligent agent contains multiple information types, multiple service dimensions, or content that needs to be presented differently, a single UI component often cannot effectively carry or present all the information. In this case, the target response information block can be sent to the application server for semantic decomposition. To facilitate understanding, let's take an example: Suppose the agent outputs a target response information block containing recommended products and reasons across multiple categories such as clothing, electronics, and home furnishings. This block corresponds to four UI components: a basic product information card, a price trend chart, a sales analysis table, and a competitor comparison component. In practice, if the interaction engine detects that the target response information block maps to multiple UI components, it triggers a semantic segmentation operation, sending the target response information block to the application server for semantic segmentation. Specifically, it can be segmented by category, with each category forming an independent group, resulting in multiple segmented semantic information groups: "Clothing recommendation group, Electronics recommendation group, Home furnishings recommendation group, each group containing a product list and recommendation reasons."

[0068] It should be noted that in complex interaction scenarios, agents sometimes output highly integrated, content-rich single response blocks. However, the various information types contained in this response block may require different UI components to render separately to achieve a better user experience. Therefore, this solution, when there are multiple target UI components corresponding to the target response block, sends the target response block to the application server for semantic splitting. This allows the user to see neat and clear information, improving the user experience. Furthermore, in streaming rendering, the mapping relationship between response blocks and UI components after the above "merging" and "splitting" processes can be found in [reference needed]. Figure 3 ,exist Figure 3 In the code, response information block 3 and response information block 4, after being merged, correspond to UI component 3, while response information block 5 corresponds to both UI components 4 and 5. The remaining response information blocks have a one-to-one correspondence with each other. Figure 3 The arrows in the text indicate the direction of data flow between response blocks and UI components in streaming rendering.

[0069] After obtaining the target rendering content, it can be populated into the target UI component to render the target UI component in the application interface of the application server. In practical applications, the target UI component has a designated placeholder area, which is used to populate service data. Specifically, the target rendering content is populated into this designated placeholder area to render the target UI component in the application interface of the application server.

[0070] It should be noted that, in this embodiment of the application, supplementary service data corresponding to the target UI component can be obtained from the application server according to the type of the target UI component, and then the supplementary service data can be associated with the target UI component and rendered in the application interface of the application server. The service data identifier corresponding to the supplementary service data is not included in the target response information block.

[0071] In practical applications, each UI component can declare its required data fields during registration, including basic data (from the agent) and supplementary service data (from the application server). Each UI component also has a defined component specification that defines "which type of UI component corresponds to which required supplementary service data".

[0072] In practice, based on the defined component specifications, supplementary service data corresponding to the target UI component is obtained from the application server according to the type of the target UI component. For example, if the target UI component is of type "product card", the obtained supplementary service data may include "merchant qualifications, logistics timeliness, service guarantee, user reviews, etc."; if the target UI component is of type "supplier comparison table", the obtained supplementary service data may include "historical cooperation records, production capacity data, certification certificates, etc."; if the target UI component is of type "order status card", the obtained supplementary service data may include "logistics trajectory, payment status, customer service remarks, etc.", and so on.

[0073] Next, the supplementary service data will be associated with and rendered in the application interface of the application server. For example, if the target UI component is a product card, the supplementary service data such as "merchant qualifications, logistics timeliness, service guarantee, and user reviews" can be displayed floatingly in various product areas of the product card.

[0074] By retrieving supplementary service data corresponding to the target UI component from the application server based on the target UI component's type, and then associating and rendering the supplementary service data with the target UI component in the application interface on the application server, users can intuitively view more comprehensive service data, further enhancing the user experience.

[0075] Based on the above, the interactive interface generation method provided in this application, after rendering the target UI component, allows the user to see a complete and easy-to-understand service information interface, without seeing the underlying implementation details of the intelligent body, thus reducing the user's cognitive load and providing a better user experience.

[0076] Figure 4 Another flowchart illustrating an interactive interface generation method provided in this application embodiment. Figure 4 As shown, the method includes the following steps: 401. Obtain the input task information triggered by the user and corresponding to the target interaction scenario.

[0077] 402. Obtain the target response information block output by the intelligent agent in response to the input task information corresponding to the target interaction scenario. The target response information block is any one of the multiple response information blocks streamed by the intelligent agent.

[0078] 403. In the set of UI components corresponding to the target interaction scenario, determine the target UI component corresponding to the target response information block.

[0079] 404. In response to the determination of the target UI component, the sequence identification information of the target UI component is stored in the determined component sequence in the first storage space. The determined component sequence stores the sequence identification information of the UI components that need to be rendered in sequence during the processing of the input task information.

[0080] 405. Determine the target rendering content corresponding to the target response information block through the application server. The target rendering content is the semantic processing result of the target response information block.

[0081] 406. Populate the target UI component with the target rendering content to render the target UI component in the application interface on the application server.

[0082] 407. In response to the rendering completion operation of the target UI component, the sequence identifier information corresponding to the target UI component is stored in the second storage space corresponding to the rendering client. The rendering client is used to render the target UI component, and the second storage space stores the sequence identifier information of the rendered UI component corresponding to the input task information.

[0083] For the specific execution process of steps 401-403 and 405-406 above, please refer to the above embodiments, which will not be repeated here.

[0084] For step 404, the target UI component here refers to the UI component that has been determined to be rendered after processing by the interaction engine. In streaming rendering, the response information block output by the agent may correspond to multiple UI components, and the rendering order of these components may be ordered (for example, the thought process component is rendered first, and then the product list component is rendered). Therefore, we need to record the determined order of these UI components in order to control the rendering process later.

[0085] To facilitate understanding, let's take an example. Suppose in a "find similar items" scenario, a user uploads a picture, and the corresponding input task is "find similar products to the items in the current picture." Based on this input task, the agent will first output a response block of its thought process. The interaction engine maps this to a thought process component (let's assume its sequence identifier is A). Then, the agent outputs a response block of a product list, which the interaction engine maps to a product list component (let's assume its sequence identifier is B). At this point, the interaction engine will store the sequence identifiers of A and B in the first storage space (used to record the sequence of UI components that need to be rendered in sequence during processing), let's assume the storage is [A, B].

[0086] For step 407, after the target UI component completes rendering on the application server's application interface, the application server sends a rendering completion notification (possibly via a callback function or event) to the interaction engine. At this time, the interaction engine stores the sequence identifier information of the target UI component in the second storage space. The second storage space stores the sequence identifier information of the rendered UI components corresponding to the input task information. This can be used to track which UI components have been rendered, enabling subsequent functions such as resume download and state restoration.

[0087] By responding to the determination of the target UI component, the sequence identification information of the target UI component is stored in the determined component sequence in the first storage space. This allows us to know which components need to be rendered and in what order, thus accurately controlling the rendering process. Furthermore, by responding to the rendering completion operation of the target UI component, the sequence identification information corresponding to the target UI component is stored in the second storage space corresponding to the rendering client. This allows us to accurately grasp the rendered UI components corresponding to the input task information, obtaining the rendering status of each UI component and laying the foundation for subsequent rapid fault diagnosis and recovery operations. In addition, by dual-caching the sequence identification information of UI components on the front end (corresponding to the second storage space) and the back end (corresponding to the first storage space), we can achieve a "data saving and acceleration" effect, meaning that already rendered content does not need to be re-downloaded. Moreover, if the content in the front end's second storage space is lost, a full recovery can be performed through the back end's first storage space.

[0088] Furthermore, it is understandable that in complex interactive scenarios, the application interface may experience session interruptions with the interaction engine for various reasons. For example, page refresh, application crashes, network disconnections, etc. Therefore, to quickly resume interrupted sessions, the interactive interface generation method provided in this application embodiment further includes: receiving a session interruption resumption request for input task information; determining the sequence identifier information of the last successfully rendered UI component based on the sequence identifier information of rendered UI components in the second storage space; searching in the first storage space for a UI component whose sequence identifier information follows that of the last successfully rendered UI component; and rendering the found UI component.

[0089] In practical applications, session interruption resumption requests can be triggered by the user in cases of application crashes or network disconnections, or automatically by the rendering client upon detecting a network disconnection and reconnection. This request may include a session identifier, corresponding to the user's task input information; one task constitutes one session. Since the second storage space maintains the sequence identifier information of successfully rendered UI components in the current session, when a session interruption resumption operation is required, the sequence identifier information of the last successfully rendered UI component can be determined in the second storage space and sent to the interaction engine. The interaction engine then searches the first storage space for all UI components with sequence numbers greater than this sequence identifier; these are the components that have not yet been rendered. The interaction engine then returns information about these unrendered UI components (including component type, required data, etc.) to the rendering client, which resumes the rendering operation from the breakpoint (i.e., the UI components following the sequence identifier information of the last successfully rendered UI component).

[0090] To facilitate understanding, the following will be combined with... Figure 5 Here is an example illustrating the overall process of resuming interrupted downloads: Suppose a user is selecting items in the app and their network connection drops (or the page is closed). They then reopen the app and want to continue their conversation. In this case, perform the following steps: The current session state is determined by the interaction engine.

[0091] The current session state includes: Generating / Continue: This indicates that the task for this session is still in progress.

[0092] Completed: This indicates that the task for this session has been completed and all data has been generated.

[0093] Failed: This means the task for this session failed and cannot continue.

[0094] In practice, if the session is interrupted and the session identifier is "session123", the status of "session123" can be directly queried through the interaction engine.

[0095] When the current session's state is "Generating / Continueable," the sequence identifier information (let's say numbers 1-5) of the successfully rendered UI components cached in the second storage space is read. Then, these UI components (numbers 1-5) are immediately rendered. The sequence identifier information of the last successfully rendered UI component (number 5) is sent to the interaction engine. The interaction engine searches for all UI components with sequence numbers greater than this sequence identifier (greater than 5) in the first storage space and returns the information of UI components greater than 5 (including component type, required data, etc.) to the rendering client. Each time the rendering client receives the sequence identifier information of a UI component, the onUpdate callback function is triggered, rendering the new UI component. This continues until the last UI component is rendered, triggering the onFinish callback function. The onUpdate callback function is triggered whenever new data is received during the streaming process; it represents incremental updates of the streaming data. The onFinish callback function is triggered when the entire streaming process is complete, marking the end of the entire data generation and transmission process.

[0096] When the current session status is "completed", the rendering client directly triggers the onUpdate callback function to render all UI components, and then triggers the onFinish callback function.

[0097] When the current session status is "failed," the onError callback function is triggered, and an error message is displayed, such as "Session failed, please restart." The onError callback function is called when an error occurs during streaming. It handles various exceptions, including network errors, server errors, and data processing errors, ensuring the application can gracefully handle errors and provide appropriate feedback to the user.

[0098] By performing the above-mentioned operations related to resuming data transmission after a session interruption, seamless and fast data transmission can be resumed after a session interruption. This ensures that data transmission can continue from the point of interruption without re-executing the user-initiated task request, thus saving computing resources and improving the user experience.

[0099] To facilitate understanding, the following section provides a detailed explanation of this solution based on an interactive interface generation system, along with specific examples: In the embodiments of this application, such as Figure 1 As shown, the interactive interface generation system includes: a central control subsystem, an intelligent agent, and an application server. The central control subsystem includes: a rendering client, an interaction engine, and a console.

[0100] In practical applications, developers first need to build interactive scenarios, configure UI components, and bind intelligent agents in the console. Specifically, developers log into the console, trigger the "Create Scenario" control, and configure the relevant interactive scenarios. For example, the interactive scenario name could be "Choose Similar Styles," and the description could be "Based on image search for similar styles, providing comparisons from multiple suppliers." Then, they select components corresponding to the "Choose Similar Styles" scenario from the "Component Marketplace," which stores multiple UI components. These components could include: an image upload panel component, a thought process display box component, a product card grid component, and a supplier comparison table component. The selected components then form the UI component set corresponding to the "Choose Similar Styles" scenario.

[0101] Next, select and bind specific agents corresponding to the "Select Same Item" scenario from the "Agent Service Marketplace" which stores multiple agents. Examples include image recognition agents, product matching agents, and supplier recommendation agents. Then, configure the mapping relationships between "UI Components," "Response Information Blocks," and "Application Services." See [link to documentation] for details. Figure 6 .exist Figure 6 In this framework, the "UI component" is named "List of Similar Items," the "Response Information Block" is named "Same Style," and the "Application Service" is named "Select Same Style," all three having a mapping relationship. In addition, the "UI component" can also be named "Semantic Parsing," "No Same Style After Selection," etc.; the "Response Information Block" can be named "Thinking Process," "Result," "Semantic Parsing," "Refusal to Answer," "No Product Result," etc.; and the "Application Service" can be named "Product Comparison Completion," "Select Similar Results," etc. These are not all listed here, and the mapping relationship between the three can be dynamically created according to actual needs. It should be noted that the above only illustrates the setup process for the "Select Same Style" scenario for subsequent descriptions; however, in actual applications, other interactive scenarios such as "Product Comparison" will also be built.

[0102] In practice, suppose a user uploads a picture of a dress to a shopping app and enters input task information (e.g., "Find me a similar dress") in the app's settings dialog box. The rendering client then packages the "dress picture" and the input task information "Find me a similar dress" and sends them to the interaction engine via the SDK. Upon receiving this input task information, the interaction engine determines the corresponding target application scenario (i.e., the "choose the same style" scenario), then identifies the corresponding agent for that scenario, and inputs the "dress picture" and the input task information "Find me a similar dress" into the agent. This results in multiple response information blocks streamed from the agent. The application server then determines the target rendering content corresponding to each of these response information blocks, for example: The target rendering content corresponding to response information block 1: 50 most similar products have been found across the entire site; The target rendering content corresponding to response information block 2: 44 identical products have been identified, and selection will begin soon; The target rendering content corresponding to response information block 3: Five high-quality sources have been initially selected (five resource images can be obtained from the application server at the same time); The target rendering content corresponding to response information block 4: Downstream price and sales analysis has been completed (the corresponding analysis tables and analysis data can be obtained from the application server at the same time). The target rendering content corresponding to response information block 5: Your product selection strategy has been learned (the corresponding strategy information can be obtained from the application server at the same time); The target rendering content corresponding to response information block 6: 3 recommended sources have been selected from 44 similar products.

[0103] Each response information block 1 corresponds to a UI component. The target rendering content is then filled into the corresponding UI component to render the corresponding UI component in the application interface of the application server. The rendered application interface can be found here. Figure 7 It should be noted that the aforementioned target rendering content can be service data. This service data can be obtained by "identifying the service data identifier of missing service data in the response information block and obtaining the service data corresponding to the service data identifier from the application server." Alternatively, it can be merged or split semantic information. This service data, merged semantic information, or split semantic information can all be obtained through the methods described in the above embodiments, and the specific implementation methods will not be elaborated here. It should be noted that in... Figure 7 In the process, the target rendering content corresponding to each response information block can each correspond to a UI component, or the target rendering content corresponding to response information blocks 1 to 6 can be collectively assigned to a UI component, while the three recommended products displayed below can be treated as a single UI component (the "Buy" and "Inquire" controls in the images of the three recommended products displayed below can be pre-configured or dynamically adjusted according to the actual situation), which is not limited here.

[0104] The following will describe in detail one or more embodiments of the interactive interface generation apparatus of this application. Those skilled in the art will understand that these apparatuses can all be configured using commercially available hardware components through the steps taught in this solution.

[0105] Figure 8 This is a schematic diagram of the structure of an interactive interface generation device provided in an embodiment of this application, such as... Figure 8 As shown, the device includes: an acquisition module 11, a determination module 12, and a rendering module 13.

[0106] The acquisition module 11 is used to acquire input task information triggered by the user and corresponding to the target interaction scenario; and to acquire the target response information block output by the agent corresponding to the target interaction scenario in response to the input task information, wherein the target response information block is any one of multiple response information blocks streamed by the agent.

[0107] The determining module 12 is used to determine the target UI component corresponding to the target response information block in the UI component set corresponding to the target interaction scenario; and to determine the target rendering content corresponding to the target response information block through the application server, wherein the target rendering content is the semantic processing result of the target response information block.

[0108] The rendering module 13 is used to fill the target UI component with the target rendering content so as to render the target UI component in the application interface of the application server.

[0109] Optionally, the acquisition module 11 is specifically used to: receive a task request triggered by a user, the task request carrying the input task information; perform interaction scenario intent recognition on the input task information to obtain intent recognition results; and determine the target interaction scenario among multiple interaction scenarios based on the intent recognition results.

[0110] Optionally, the determining module 12 is specifically configured to: obtain the type identifier corresponding to the target response information block; based on a pre-configured mapping relationship between the response information block type identifier and UI components, determine the target UI component corresponding to the type identifier of the target response information block in the set of UI components corresponding to the target interaction scenario; identify the service data identifier for missing service data in the target response information block; obtain the service data corresponding to the service data identifier from the application server, wherein the target rendering content includes the service data; and, according to the set information block semantic merging rules, if it is determined that the target response information block is one of at least one response information block that needs to be semantically merged, then send the target response information block to the application server; receive the merged semantic information output by the application server according to the information block semantic merging rules, wherein the target rendering content includes the merged semantic information; and, if there are multiple target UI components corresponding to the target response information block, then send the target response information block to the application server for semantic splitting; receive multiple split semantic information output by the application server, wherein the target rendering content includes the multiple split semantic information.

[0111] Optionally, the acquisition module 11 is specifically used to: acquire supplementary service data corresponding to the target UI component from the application server according to the type of the target UI component, wherein the service data identifier corresponding to the supplementary service data is not included in the target response information block; the rendering module 13 is specifically used to: associate and render the supplementary service data with the target UI component in the application interface of the application server.

[0112] Optionally, the device further includes: a response module, configured to, in response to the determination of the target UI component, store the sequence identification information of the target UI component into a determined component sequence in a first storage space, wherein the determined component sequence stores the sequence identification information of the UI components that need to be rendered sequentially during the processing of the input task information; and, in response to the rendering completion operation of the target UI component, store the sequence identification information corresponding to the target UI component into a second storage space corresponding to the rendering client, wherein the rendering client is used to render the target UI component, and the second storage space stores the sequence identification information of the rendered UI components corresponding to the input task information.

[0113] Optionally, the rendering module 13 is further configured to: receive a session interruption resumption request for the input task information; Based on the sequence identifier information of the rendered UI components in the second storage space, determine the sequence identifier information of the last successfully rendered UI component; search for the UI component whose sequence identifier information follows that of the last successfully rendered UI component in the first storage space; and render the found UI component.

[0114] Optionally, the determining module 12 is further configured to: determine the UI component set corresponding to the target interaction scenario based on the user's feature information and / or the feature information of the application corresponding to the application interface.

[0115] Figure 8 The device shown can perform the steps in the interactive interface generation method in the foregoing embodiments. For detailed execution process and technical effects, please refer to the description in the foregoing embodiments, which will not be repeated here.

[0116] Figure 9 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Figure 9 As shown, in practice, this electronic device includes a memory 21 and a processor 22.

[0117] Memory 21 is used to store computer programs and can be configured to store various other data to support operation on the electronic device. Examples of this data include instructions for any application or method used to operate on the electronic device, data structures, contact data, phone book data, messages, pictures, videos, etc.

[0118] The processor 22, coupled to the memory 21, is used to execute the computer program in the memory 21 to implement the interactive interface generation method provided in the foregoing embodiments.

[0119] Furthermore, such as Figure 9 As shown, the electronic device also includes other components such as a communication component 23, a display 24, a power supply component 25, and an audio component 26. Figure 9 The diagram only shows some components and does not mean that the electronic device includes only these components. Figure 9 The components shown are as follows. The electronic device in this embodiment can be a terminal device such as a desktop computer, laptop computer, smartphone, or IoT device, or a server device such as a conventional server, cloud server, or server array.

[0120] The aforementioned memory can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random-Access Memory (SRAM), Electrically Erasable Programmable Read Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0121] The aforementioned communication component is configured to facilitate wired or wireless communication between the device containing the communication component and other devices. The device containing the communication component can access wireless networks based on communication standards, such as 2G, 3G, 4G / LTE, 5G, or combinations thereof. In one exemplary embodiment, the communication component receives broadcast signals or broadcast-related information from an external broadcast management system via a broadcast channel.

[0122] The aforementioned display includes a screen, which may include a Liquid Crystal Display (LCD) and a Touch Panel (TP). If the screen includes a Touch Panel, the screen can be implemented as a touchscreen to receive input signals from the user. The Touch Panel includes one or more touch sensors to sense touches, swipes, and gestures on the Touch Panel. The touch sensors can sense not only the boundaries of touch or swipe actions but also the duration and pressure associated with the touch or swipe operation.

[0123] The aforementioned power supply components provide power to various components within the device in which they reside. These power supply components may include a power management system, one or more power sources, and other components associated with generating, managing, and distributing power to the device in which they reside.

[0124] The aforementioned audio component can be configured to output and / or input audio signals. For example, the audio component includes a microphone (MIC) configured to receive external audio signals when the device containing the audio component is in an operating mode, such as call mode, recording mode, or voice recognition mode. The received audio signals can be further stored in memory or transmitted via a communication component. In some embodiments, the audio component also includes a speaker for outputting audio signals.

[0125] Accordingly, embodiments of this application also provide a computer-readable storage medium storing a computer program, which, when executed by a processor, enables the processor to implement the steps in the above-described method embodiments. The computer-readable storage medium includes volatile or non-volatile components, or a combination thereof, and can be removable or non-removable. Examples of computer-readable storage media include, but are not limited to, phase-change random access memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random-access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), flash memory or other memory technologies, CD-ROM, Digital Video Disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium. Accordingly, this application also provides a computer program product, which includes a computer program or instructions that, when executed by a processor, cause the processor to implement the steps in the above method embodiments. It should be understood that each step or combination of steps in the above method flow can be implemented by the computer program or instructions. Furthermore, these computer programs or instructions can be applied to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device, enabling the processor of the general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing device to function as an apparatus for implementing the corresponding functions in the above method embodiments.

[0126] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A method for generating an interactive interface, characterized in that, include: Obtain the input task information triggered by the user corresponding to the target interaction scenario; Obtain the target response information block output by the intelligent agent corresponding to the target interaction scenario in response to the input task information, wherein the target response information block is any one of the multiple response information blocks streamed by the intelligent agent; In the set of UI components corresponding to the target interaction scenario, determine the target UI component corresponding to the target response information block; The target rendering content corresponding to the target response information block is determined by the application server, and the target rendering content is the semantic processing result of the target response information block; The target rendering content is filled into the target UI component so that the target UI component is rendered in the application interface of the application server.

2. The method according to claim 1, characterized in that, The step of obtaining the input task information triggered by the user and corresponding to the target interaction scenario includes: Receive a task request triggered by a user, wherein the task request carries the input task information; The input task information is subjected to interactive scene intent recognition to obtain intent recognition results; Based on the intent recognition results, the target interaction scenario is determined among multiple interaction scenarios.

3. The method according to claim 1, characterized in that, The step of determining the target UI component corresponding to the target response information block from the set of UI components corresponding to the target interaction scenario includes: Obtain the type identifier corresponding to the target response information block; Based on the pre-configured mapping relationship between response information block type identifiers and UI components, the target UI component corresponding to the type identifier of the target response information block is determined in the UI component set corresponding to the target interaction scenario.

4. The method according to claim 1, characterized in that, The step of determining the target rendering content corresponding to the target response information block through the application server includes: Identify the service data identifier that is missing service data in the target response information block; The service data corresponding to the service data identifier is obtained from the application server, and the target rendering content includes the service data.

5. The method according to claim 1, characterized in that, The step of determining the target rendering content corresponding to the target response information block through the application server includes: According to the set semantic merging rules for information blocks, if the target response information block is determined to be one of at least one response information block that needs to be semantically merged, then the target response information block is sent to the application server. The application server receives merged semantic information output according to the information block semantic merging rules, and the target rendering content includes the merged semantic information.

6. The method according to claim 1, characterized in that, The step of determining the target rendering content corresponding to the target response information block through the application server includes: If there are multiple target UI components corresponding to the target response information block, the target response information block is sent to the application server for semantic segmentation. The application server outputs multiple split semantic information, and the target rendering content includes the multiple split semantic information.

7. The method according to claim 1, characterized in that, The method further includes: Based on the type of the target UI component, supplementary service data corresponding to the target UI component is obtained from the application server. The service data identifier corresponding to the supplementary service data is not included in the target response information block. Rendering the target UI component in the application interface of the application server includes: The supplementary service data is associated with and rendered with the target UI component in the application interface of the application server.

8. The method according to claim 1, characterized in that, The method further includes: In response to the determination of the target UI component, the sequence identification information of the target UI component is stored in the determined component sequence in the first storage space. The determined component sequence stores the sequence identification information of the UI components that need to be rendered sequentially during the processing of the input task information. In response to the rendering completion operation of the target UI component, the sequence identification information corresponding to the target UI component is stored in the second storage space corresponding to the rendering client, wherein the rendering client is used to render the target UI component, and the second storage space stores the sequence identification information of the rendered UI component corresponding to the input task information.

9. The method according to claim 8, characterized in that, Also includes: Receive a session interruption resume request for the input task information; Based on the sequence identifier information of the rendered UI components in the second storage space, determine the sequence identifier information of the last successfully rendered UI component; Search the first storage space for the UI component whose sequence identification information follows the sequence identification information of the last successfully rendered UI component; Render the found UI components.

10. The method according to claim 1, characterized in that, The method further includes: Based on the user's feature information and / or the feature information of the application corresponding to the application interface, determine the set of UI components corresponding to the target interaction scenario.

11. An interactive interface generation system, characterized in that, include: Central control subsystem, intelligent agent, application server; The central control subsystem includes: a rendering client and an interaction engine; The interaction engine is used to acquire input task information triggered by the user corresponding to the target interaction scenario; acquire the target response information block output by the agent corresponding to the target interaction scenario in response to the input task information; determine the target UI component corresponding to the target response information block in the UI component set corresponding to the target interaction scenario; determine the target rendering content corresponding to the target response information block through the application server; and send the target rendering content and the target UI component to the rendering client, wherein the target response information block is any one of multiple response information blocks streamed by the agent, and the target rendering content is the semantic processing result of the target response information block; The application server is used to determine the target rendering content based on the target response information block; The rendering client is used to populate the target UI component with the target rendering content so as to render the target UI component in the application interface of the application server.

12. An electronic device, characterized in that, include: The system includes a memory, a processor, and a communication interface; wherein the memory stores executable code, and when the executable code is executed by the processor, the processor performs the interactive interface generation method as described in any one of claims 1 to 10.

13. A non-transitory machine-readable storage medium, characterized in that, The non-transitory machine-readable storage medium stores executable code, which, when executed by a processor of an electronic device, causes the processor to perform the interactive interface generation method as described in any one of claims 1 to 10.

14. A computer program product, characterized in that, include: A computer program, when executed by a processor of an electronic device, causes the processor to perform the interactive interface generation method as described in any one of claims 1 to 10.

Images