Task execution method, system, device and equipment and storage medium

Abstract

The embodiment of the invention provides a task execution method, system, device and equipment and a storage medium, and the method comprises the steps: responding to received task indication information of a target development task, and calling a task decomposition intelligent module to generate natural language instructions of a plurality of to-be-executed tasks based on the task indication information; for any to-be-executed task, a task configuration intelligent module is called to transmit a natural language instruction of the to-be-executed task to a task execution container corresponding to the to-be-executed task, and any task execution container in the task execution container pool comprises a plurality of execution intelligent modules; and for any to-be-executed task, calling a plurality of execution intelligent modules in the task execution container of the to-be-executed task to execute the to-be-executed task based on the corresponding natural language instruction. By adopting the implementation mode, the plurality of intelligent modules are triggered to cooperate with each other to automatically execute the development task, so that front-end development in a low-code mode can be realized, and the development efficiency can be improved.

Description

TECHNICAL FIELD

[0001] Embodiments of the present application relate to the field of Artificial Intelligent (AI) technology, and particularly relate to a task execution method, system, device, apparatus and storage medium. BACKGROUND

[0002] Front-end development is a process of building a visual interactive interface to provide an interactive interface to a user through the visual interactive interface, and converting the interactive operation of the user into an instruction triggering a back-end function. The front-end development can include a development process of defining interface elements (such as container, form, control and the like elements), designing page layout and presentation effect of interface elements, editing interactive logic between interface elements and back-end functions, and the like. It can be seen that the front-end development not only needs a large amount of code editing, but also needs to ensure that the edited code can support the interface elements to perform various tasks.

[0003] In order to improve the efficiency of front-end development, some current front-end development is assisted by AI tools. However, the current mainstream front-end development assisted by AI tools usually generates recommended fields or options by means of the natural language understanding capability of AI tools, and the main development process still strongly depends on code editing of the developer. It can be seen that the current front-end development method still has the problem of low development efficiency. SUMMARY

[0004] To overcome the problems in the related art, embodiments of the present application provide a task execution method, system, device, apparatus and storage medium.

[0005] According to a first aspect of embodiments of the present application, a task execution method is provided, the method comprising: in response to receiving task indication information of a target development task, calling a task decomposition intelligent module to generate natural language instructions of a plurality of to-be-executed tasks based on the task indication information; for any to-be-executed task, calling a task configuration intelligent module to transmit the natural language instruction of the to-be-executed task to a task execution container corresponding to the to-be-executed task, the task execution container being any in a preset task execution container pool, any task execution container in the task execution container pool comprising a plurality of execution intelligent modules; for any to-be-executed task, calling a plurality of execution intelligent modules in the task execution container of the to-be-executed task to execute the to-be-executed task based on the corresponding natural language instruction.

[0006] According to a second aspect of embodiments of the present application, a task execution system is provided, the system comprising a task decomposition intelligent module, a task configuration intelligent module and a task execution container pool, any task execution container in the task execution container pool comprising a plurality of execution intelligent modules, The task decomposition intelligent module is configured to, in response to receiving task indication information of a target development task, generate natural language instructions of a plurality of to-be-executed tasks based on the task indication information. The task configuration intelligent module is configured to, for any to-be-executed task, transmit the natural language instructions of the to-be-executed task to a task execution container corresponding to the to-be-executed task, the task execution container being any of a preset task execution container pool. Any task execution container is configured to invoke a plurality of execution intelligent modules to execute the to-be-executed task based on the corresponding natural language instructions.

[0007] According to a third aspect of the embodiments of the present application, a task execution device is provided, and the device comprises: A generation module is configured to, in response to receiving task indication information of a target development task, invoke a task decomposition intelligent module to generate natural language instructions of a plurality of to-be-executed tasks based on the task indication information. A transmission module is configured to, for any to-be-executed task, invoke a task configuration intelligent module to transmit the natural language instructions of the to-be-executed task to a task execution container corresponding to the to-be-executed task, the task execution container being any of a preset task execution container pool, and any task execution container in the task execution container pool comprising a plurality of execution intelligent modules. An execution module is configured to, for any to-be-executed task, invoke a plurality of execution intelligent modules in the task execution container of the to-be-executed task to execute the to-be-executed task based on the corresponding natural language instructions.

[0008] According to a fourth aspect of the embodiments of the present application, an electronic device is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, the processor executing the program to implement the method of the first aspect.

[0009] According to a fifth aspect of the embodiments of the present application, a computer readable storage medium is provided, having a computer program stored thereon, the program being executed by a processor to implement the method of the first aspect.

[0010] According to a sixth aspect of the embodiments of the present application, a computer program product is provided, comprising a computer program, the computer program being executed by a processor to implement the method of the first aspect.

[0011] The technical solutions provided by the embodiments of the present application can have the following beneficial effects: The technical solution of this application receives task instruction information for a target development task. Then, it calls a task decomposition intelligent module to generate natural language instructions for multiple tasks to be executed. In other words, using this technical solution, developers can describe development tasks by inputting text instructions such as task instruction information. The task decomposition intelligent module then decomposes the development task described by the text instructions into tasks to be executed, also described by text, and assigns these tasks to corresponding task execution containers for execution. Each task execution container also executes its corresponding task through the collaboration of multiple intelligent modules. Therefore, in this technical solution, developers can trigger multiple intelligent modules to automatically execute the development task by inputting the development task using natural language, eliminating the need for extensive manual code editing. This facilitates low-code front-end development, thereby improving development efficiency and lowering the professional threshold for front-end development. Furthermore, the collaboration of multiple intelligent modules to execute development tasks increases the automation level of front-end development, further improving development efficiency.

[0012] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this disclosure. Attached Figure Description

[0013] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the embodiments of this application will be briefly described below. It should be understood that those skilled in the art can obtain other drawings based on these drawings without any creative effort.

[0014] Figure 1A This application provides an exemplary task execution system architecture diagram. Figure 1B This application provides an exemplary data flow diagram among multiple intelligent modules. Figure 2 An exemplary method flow diagram of the task execution method provided in the embodiments of this application; Figure 3A A flowchart illustrating an exemplary task execution method provided in this application embodiment; Figure 3B Signaling interaction diagram of an exemplary task execution method provided in the embodiments of this application; Figure 4A An exemplary interface diagram of a front-end development scenario provided in this application embodiment; Figure 4B An exemplary interface diagram for a front-end development scenario provided in this application embodiment. Figure Two ; Figure 4CA schematic diagram of an exemplary interface for a front-end development scenario provided in this application embodiment; Figure 5 This is an exemplary schematic diagram of the task execution device provided in the embodiments of this application; Figure 6 This is an exemplary structural diagram of an electronic device provided in an embodiment of this application. Detailed Implementation

[0015] The technical solutions of the embodiments of this application will now be described with reference to the accompanying drawings.

[0016] The terminology used in the following embodiments of this application is for the purpose of describing specific embodiments and is not intended to limit the technical solutions of this application. As used in the specification and appended claims of this application, the singular expressions "a," "an," "the," "the," "the," and "this" are intended to include the plural expressions as well, unless the context clearly indicates otherwise. It should also be understood that although the terms first, second, etc., may be used in the following embodiments to describe a class of objects, the objects are not limited to these terms. These terms are used to distinguish specific implementations of that class of objects.

[0017] It should be noted that 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, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant 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.

[0018] Front-end development, also known as client-side development, refers to the process of building websites or web applications with visual interactive interfaces using a series of web technologies (such as Hyper Text Markup Language (HTML), Cascading Style Sheets (CSS), and JavaScript). The completed client-side application can run in a browser or WebView environment, providing users with visual interactive interface elements (such as text boxes, buttons, and controls) and coupling with backend functionality. The main processes of front-end development can include several steps: basic structure building, style design and adaptation, and interaction logic implementation. Basic structure building refers to constructing the page framework, including defining elements such as containers, lists, forms, and buttons. Style design and adaptation refers to handling the visual presentation of the page, including page layout, responsive breakpoints, animation effects, and browser compatibility, to accurately present the style of the design draft. Interactive logic implementation refers to building the coupling logic between interactive events and backend functions. This includes handling user actions (such as clicks, input, scrolling, etc.), data acquisition, API calls, state management, and dynamic content updates. Developing these functions typically requires extensive code editing. With technological advancements, the scope of front-end development has expanded to include complex single-page applications and cross-platform development (such as web pages on computers, mobile applications, and mini-programs embedded in applications across different clients). As the diversity and complexity of internet services increase, the complexity of front-end development in areas such as architecture construction, state management, and consistency assurance in cross-platform development is growing exponentially. Relying on developers to simply edit code for front-end development results in low development efficiency.

[0019] To improve the efficiency of front-end development, some current front-end development methods leverage AI tools, primarily chatbots and copilots. Chatbots provide responses or perform simple tasks based on developer input, such as data field matching and style optimization; however, the main development process still heavily relies on developer coding. Copilots generate various recommended options based on developer input and historical context, including different page elements (forms, charts, buttons) and suggested bound data fields for developers to choose from. However, this approach only supports low-complexity tasks; for complex tasks, developers still need to write code, and selecting from the recommended options depends on their expertise. In conclusion, current front-end development methods still suffer from low efficiency.

[0020] In view of this, the technical solution provided in this application deploys multiple intelligent modules to receive task instruction information for a target development task expressed in text. Then, through the cooperation of these multiple intelligent modules, the task instruction information is decomposed into natural language instructions for multiple tasks to be executed, and the corresponding intelligent modules are automatically executed to fulfill the target development task. As can be seen, in this technical solution, developers can trigger multiple intelligent modules to automatically execute the development task by inputting the development task using natural language, eliminating the need for extensive manual coding. This facilitates low-code front-end development, thereby improving development efficiency and lowering the professional threshold for front-end development. Furthermore, the cooperation of multiple intelligent modules to execute development tasks increases the automation level of front-end development, further enhancing its efficiency.

[0021] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will be described below with reference to the accompanying drawings.

[0022] The task execution method provided in this application embodiment can be applied to a task execution system, which can be deployed in electronic devices such as computers, game consoles, or personal computers (PCs), or in cloud computers, distributed clusters, etc. According to its functions and calling logic, the task execution system in this application embodiment can be represented as a layered architecture, with each layer deploying corresponding functional tools and performing corresponding functional tasks. For example... Figure 1A As shown, the task execution system may include a development task input layer, a component layer, and an engine layer. The development task input layer communicates with the component layer, and the component layer communicates with the engine layer, through an application programming interface (API).

[0023] The development task input layer can be a user-facing input interface and can be configured as a flow-driven layer for development tasks. It can provide a visual input interface for the target development task, receiving development task instructions expressed in natural language or images. For example, the visual input interface of the development task input layer could be a Chat Bot floating ball (such as...). Figures 4A to 4CThe task input layer is presented in the form shown below. In some embodiments, the development task input layer can deploy task decomposition function modules corresponding to different types of development tasks. Each task decomposition function module is used to understand the task instruction information of the corresponding type and decompose the corresponding development task into more granular tasks to be executed. The task decomposition function modules are as follows: Figure 1A The diagram illustrates page generation, data source binding, style modification, and component adjustment. Page generation handles the task of creating a complete page. Data source binding is used to bind and configure the display data with the given backend interface or database. Style modification handles the task of adjusting the visual effects (such as color, font, and layout) of the generated page. Component adjustment handles tasks such as adding, deleting, modifying, and replacing specific components on the page.

[0024] The component layer is configured to convert natural language instructions input from the development task input layer into system tasks, and to call components (also called components or tools) in the browser to execute the corresponding system tasks, thereby automatically achieving low-code front-end development without requiring developers to edit code. In some embodiments, multiple intelligent modules and multiple components can be deployed in the component layer. These intelligent modules can coordinate with each other to jointly execute development tasks. Optionally, while some intelligent modules are executing development tasks, other intelligent modules can supervise and adjust the execution steps of the development tasks. As an example, during the execution of development tasks by multiple intelligent modules, each intelligent module can call a matching component from multiple components to execute the corresponding task according to its functional settings.

[0025] In some embodiments, the multiple intelligent modules may include intelligent modules and intelligent module groups that perform different functions. According to the task execution method flow of this application, the multiple intelligent modules may include a task configuration intelligent module and multiple task execution containers. These multiple task execution containers form a task execution container pool. Each task execution container includes multiple execution intelligent modules, and the tasks that these multiple task execution containers can execute are different. The task configuration intelligent module can be used to coordinate and manage multiple tasks to be executed within a development task, so as to assign each task to be executed to a corresponding task execution container. In some embodiments, during the execution of a corresponding task to be executed, any task execution container can flexibly adjust the parameters and steps of unexecuted subtasks in the task to be executed based on the execution results of the already executed task steps.

[0026] Any intelligent module can be implemented as a functional module with natural language understanding and task execution capabilities, such as an AI agent. An intelligent module is a dynamic integration of model functionality and task execution capabilities. It can understand received natural language instructions and, based on the understanding, determine the components to be invoked. Furthermore, it generates data structure description information for the invoked components. After supplementing the parameters based on this data structure description information, the corresponding component can be invoked. As an example, the data structure description information can be schema information. A schema is a structured description framework used to define the organizational structure, constraints, and semantic relationships of data, knowledge, or systems. In computer science, a schema is a formal representation of metadata, describing the structure, type, relationships, and constraints of data. In this embodiment, the schema information can be, for example, information described in JSON format.

[0027] In some embodiments, multiple prompts can be set in the component layer, each used to guide the intelligent module to execute a corresponding task. The prompt can refer to a prompt word from the large language model, where the prompt is the text or sentence input to the large language model, serving as the starting point for guiding the product recommendation model to generate response information or continue generating text. A prompt can be at least one of a sentence, a question, a descriptive paragraph, or a series of instructions. As an example, the first prompt can guide the task configuration intelligent module to parse the semantics of each task to be executed, assign each task to a functionally matching task execution container, and trigger multiple task execution containers to execute the corresponding tasks in parallel. As an example, the second prompt can guide a task execution container to break down the task to be executed into subtasks, transmit different subtasks to the corresponding intelligent module group according to the execution steps of the subtasks, and adjust the execution steps of each subtask as needed during the execution of each subtask.

[0028] Multiple components can include, for example, a merging component, a schema completion component, a page building component, a behavior binding component, a data source binding component, and a page element generation component. The merging component integrates style rules, data models, and interactive behavior logic from different information sources (such as user-inputted commands or design drafts recognized by intelligent modules) into a unified structured tree. The schema completion component automatically supplements or corrects existing data structure descriptions to obtain complete and correct component call parameters. The page building component retrieves information about existing components and layouts based on the current page structure, providing context for page modifications or updates. The behavior binding component associates defined user interaction events (such as clicks and pull-to-refresh) with specific component functions or data operations. The data source binding component configures the connection between component fields and specified backend data interfaces. The page element generation component constructs visual page elements based on schema information.

[0029] As can be seen, in this embodiment of the application, multiple intelligent modules cooperate with each other based on natural language instructions to call matching components to perform development tasks. This not only eliminates the need for developers to do a lot of code editing, realizing "low-code" front-end development and helping to lower the technical threshold of front-end development, but also helps to improve the automation level of front-end development by triggering each intelligent module to automatically call components to perform corresponding tasks based on natural language instructions. This can improve the development efficiency of front-end development to a certain extent.

[0030] The engine layer is configured to render the structured information processed by the component layer into visual, interactive interface elements to obtain the webpage presented by the front-end development. Different functional system engines can be deployed in the engine layer. Each engine receives the schema information output by the component layer, parses and executes the schema, and then executes functions to generate page code and UI. In some embodiments, the engine layer may include a UI engine, an encapsulation engine, and a design-to-code (D2C) engine. The UI engine can be used for rendering and managing basic user interface components such as buttons, input boxes, and layout containers. The encapsulation engine can be used to combine and encapsulate components into reusable "blocks," improving construction efficiency; for example, combining components into a complete search bar. The D2C engine can be used to automatically identify and convert visual design drafts into schema information or component code containing only data structures.

[0031] It should be understood that the above description of each functional layer of the task execution system is merely illustrative and does not constitute a limitation on the functional layers of the task execution system in this application embodiment. In actual implementation scenarios, the task execution system may include more or fewer functional layers, and each layer may contain more or fewer functional modules. This application embodiment does not limit this.

[0032] Figure 1A The functions and capabilities of the various intelligent modules involved are different, and the data flow in the process of cooperation between multiple intelligent modules can be described as follows: Figure 1B As shown.

[0033] like Figure 1B As shown, according to logical function, the task execution system may include a task identification intelligent module 11, a task decomposition intelligent module 12, a task configuration intelligent module 13, and a task execution container pool 14. The task execution container pool 14 may include multiple task execution containers such as task execution container 14A, task execution container 14B, and task execution container 14C. The task identification intelligent module 11 can be deployed in... Figure 1A The task input layer, task decomposition intelligent module 12, task configuration intelligent module 13, and task execution container pool 14 can be deployed in the development task input layer. Figure 1A The component layer in the system. The task execution containers in the task identification intelligent module 11, task decomposition intelligent module 12, task configuration intelligent module 13, and task execution container pool 14 can exchange information via API.

[0034] The task recognition intelligent module 11 can receive natural language instructions input by developers in the form of visual interface elements. For example, the task recognition intelligent module 11 can be visualized as a floating ball. The task recognition intelligent module 11 can be used to receive initial natural language instructions input by developers and to detect whether the initial natural language instructions are instructions instructing a development task. If the initial natural language instructions are instructions instructing a development task, the initial natural language instructions are transmitted to the task decomposition intelligent module 12 to execute subsequent task execution work according to this embodiment; if the initial natural language instructions are not instructions instructing a development task, response information corresponding to the initial natural language instructions can be generated and output. As an example, the task recognition intelligent module 11 can determine whether the initial natural language instructions are instructions instructing a development task by detecting whether the initial natural language instructions contain task features of the development task. Task features may include descriptive information about the development task or page images.

[0035] The task decomposition intelligent module 12 is used to decompose the task instruction information (i.e. the initial natural language instruction transmitted by the task recognition intelligent module 11) into multiple tasks to be executed and generate natural language instructions for each task to be executed when it receives the task instruction information (i.e. the initial natural language instruction transmitted by the task recognition intelligent module 11), combined with the understanding of the task instruction information and the functions supported by each task execution container in the task execution container pool 14.

[0036] The task configuration intelligence module 13 manages the task execution status of each task execution container. In some embodiments, the task configuration intelligence module 13 can assign multiple tasks to be executed, decomposed by the task decomposition intelligence module 12, to matching task execution containers. In some embodiments, the task configuration intelligence module 13 can maintain the task queue of each task execution container and detect the status of each task execution container. For example, the task configuration intelligence module 13 can control multiple task execution containers to execute their corresponding tasks in parallel.

[0037] Task execution containers 14A, 14B, and 14C in task execution container pool 14 can be used to execute different development tasks. For example, task execution container 14A can be used to execute page generation-related tasks, task execution container 14B can be used to execute component adjustment-related tasks, and task execution container 14C can be used to execute style modification-related tasks. Any task execution container can contain multiple smart modules, and any task execution container can execute corresponding tasks by calling multiple deployed smart modules. Figure 1A As can be seen from the schematic diagram of the functional layers, any task execution container can execute a task by calling browser components, and multiple task execution containers can execute the corresponding tasks in parallel, that is, they can call browser components to execute tasks in parallel.

[0038] Traditional front-end development relies on browser developer tools and local development environments, rather than calling browser components. Furthermore, browser-based development typically uses single-threaded task execution, resulting in low efficiency and resource utilization. Therefore, this implementation improves efficiency and resource utilization by controlling multiple task execution containers to execute tasks in parallel and calling browser components concurrently.

[0039] Please refer to Figure 2 , Figure 2 An exemplary task execution method is shown, which can be performed by... Figure 1A The illustrated task execution system is being executed. This task execution method may include the following steps: In step S101, in response to receiving the task instruction information of the target development task, the task decomposition intelligent module is invoked to generate natural language instructions for multiple tasks to be executed based on the task instruction information.

[0040] In step S102, for any task to be executed, the task configuration intelligent module is invoked to transmit the natural language instructions of the task to be executed to the task execution container corresponding to the task.

[0041] In step S103, for any task to be executed, multiple execution intelligence modules in the task execution container of the task to be executed are invoked to execute the task based on the corresponding natural language instructions.

[0042] The task instruction information can refer to the initial natural language instruction containing task characteristics, and the development task represented by the task characteristics is the target development task. The task execution container is any one of a preset task execution container pool, and each task execution container in the pool includes multiple execution intelligent modules. Therefore, in this technical solution, the received information is the task instruction information of the target development task. Then, the task decomposition intelligent module is invoked to generate natural language instructions for multiple tasks to be executed. In other words, using the technical solution of this application, developers can describe development tasks by inputting text instructions such as task instruction information. Then, the task decomposition intelligent module decomposes the development task described by the text instructions into tasks to be executed, also described by text, and assigns the tasks to be executed to the corresponding task execution containers for execution. Each task execution container also executes the corresponding task by means of multiple intelligent modules working together. As can be seen, in this technical solution, developers can use natural language to input development tasks, which will trigger multiple intelligent modules to cooperate and automatically execute the development tasks. This eliminates the need for extensive manual coding, which is conducive to low-code front-end development, thereby improving development efficiency and lowering the professional threshold for front-end development. Furthermore, the cooperation of multiple intelligent modules to execute development tasks can improve the automation level of front-end development, thereby further improving the development efficiency of front-end development.

[0043] In some embodiments, the task execution system further includes a task identification intelligent module. Before step S101 above, in response to receiving an initial natural language instruction, the task identification intelligent module can detect whether the initial natural language instruction contains task features. If it does, it can determine that the initial natural language instruction is task instruction information for the target development task, and transmit the initial natural language instruction as the task instruction information to the task decomposition intelligent module. If it does not contain task features, it can determine that the initial natural language instruction is a query message and not task instruction information for the target development task, and output the response message to the initial natural language instruction.

[0044] For example, the task features include at least one of a task descriptive term and a page image. The descriptive term is a phrase related to front-end development calls, such as describing an interface, component members, etc., for example, "Please refer to my interface address 'https: / / oneapi / list'", or "My component members are 'form component' and 'table component'". The page image may include images of the updated page, images of the updated page, component images, etc. This application embodiment does not limit this.

[0045] After receiving the task instruction information transmitted by the task recognition intelligent module, the task decomposition intelligent module can identify the task features in the task instruction information, parse the development intent of the target development task based on the task features, and generate natural language instructions for the multiple tasks to be executed based on the development intent and the attributes of each task execution container in the task execution container pool. The natural language instruction for any task to be executed may include the task execution container identifier, the content of the task to be executed, and the component call address.

[0046] In some embodiments, the task decomposition intelligent module can generate multiple tasks to be executed based on task indication information, and generate natural language instructions for each task to be executed, according to pre-deployed task decomposition prompts. For example, the task decomposition prompts are used to guide the task decomposition intelligent module to decompose specific executable task steps according to the task indication information.

[0047] The guidance logic for task breakdown prompts is as follows: 1. Understand the division of labor and specific capabilities of each task execution container in the task execution container pool.

[0048] 2. Understand user questions (i.e. task instructions). When user questions provide materials such as images, analyze the user's intent by combining the materials with the user question.

[0049] 3. Decompose the problem-solving steps based on the capabilities of each task's execution container.

[0050] 4. Returns the result in a JSON structure.

[0051] When the task features include page images, and the page images contain graphics of at least one development component, directly identifying the page images would require a large amount of data to be identified. Furthermore, it would be difficult to extract the task chain relationship between the development components and the page based on the overall page image, making it impossible to break down the development task into smaller, more granular tasks that match the task execution container. In some embodiments, this is addressed by using an image segmentation tool to segment the page images, obtaining at least one development component image block, where each development component image block contains a graphic of a development component. Semantic features of each of the at least one development component image block are extracted. The development intent of the target development task is determined based on the task description and the semantic features of each development component image block.

[0052] For example, task features include page visual images. For these images, an image segmentation tool is used to segment them into form component images and title component images. Then, the task decomposition intelligent module can determine the development intent as "generate a new page" based on these images. The task decomposition intelligent module can generate multiple tasks to be executed, such as "generate form component schema -> insert the form component schema under the title component -> update the page," based on the functionality of each task execution container pool: "generate form component schema -> insert the form component schema under the title component -> update the page." Here, "->" indicates the "next step" for each task to be executed.

[0053] It should be understood that the above "generate form component schema" and "insert the form component schema under the title component" are natural language instructions used to describe or instruct the task, and do not generate the corresponding "schema".

[0054] By adopting this implementation method, the interface elements contained in the page images are identified separately, which helps to improve the accuracy of identifying component types, attributes and layout relationships. In turn, it is easier to generate smaller-granular tasks to be executed, thus making it easier to define the task chain of the tasks to be executed and to match them with the intelligent module.

[0055] Based on the aforementioned description of the natural language instructions for the tasks to be executed, it can be seen that any natural language instruction for a task to be executed may include a task execution container identifier. After the task decomposition intelligent module decomposes the natural language instructions for multiple tasks to be executed, it can transmit the natural language instructions for multiple tasks to be executed to the task configuration intelligent module. The task configuration intelligent module can configure the tasks to be executed to the corresponding task execution containers according to the task execution container identifier in each natural language instruction.

[0056] In some embodiments, the task configuration intelligence module can maintain global task information for the task execution container pool, as well as the task queues for tasks to be executed by each task execution container. Upon receiving multiple tasks to be executed from the task decomposition intelligence module, the task configuration intelligence module can update the global task information of the task execution container pool based on these multiple tasks. For any given task execution container, the task configuration intelligence module can monitor whether the container is idle. If the container is not idle, the monitoring ends, and the module waits for the next monitoring cycle. If the container is idle, tasks are assigned to it according to the order of tasks in its corresponding task queue, and the natural language instructions for the tasks are transmitted to the corresponding task execution container so that the container can execute the corresponding task.

[0057] In some embodiments, it is detected whether the task execution containers of the plurality of tasks to be executed are all idle. If the task execution containers of the plurality of tasks to be executed are all idle, the task configuration intelligent module can call the task execution containers of the plurality of tasks to be executed to execute the corresponding tasks in parallel.

[0058] The task execution containers execute tasks by calling browser components through multiple intelligent modules. Each task execution container in the pool has different functions and capabilities; that is, each task execution container should call different browser components. Based on this, task execution containers that call multiple tasks to be executed can execute their corresponding tasks in parallel. In implementation, this means: calling multiple browser components in parallel to execute tasks. In this way, by using the task configuration intelligent module to centrally manage the task execution container pool, global management of each task execution container is achieved, and parallel invocation of multiple task execution containers and browser components can be performed concurrently, thus improving execution efficiency and resource utilization.

[0059] In some embodiments, the multiple intelligent modules contained in any task execution container may correspond to at least one module group, and the at least one module group may be used to execute tasks of different task types. For example, the at least one module group may include a component task module group, a page update module, and a page rendering module, wherein the component task module group is used to execute a task type of component invocation, the page update module is used to execute a task type of page update, and the page rendering module is used to execute a task type of page rendering. In some implementation scenarios, the number of module groups contained in each task execution container in the task execution container pool may be different. (See reference...) Figure 1BThe illustrated task execution container pool 14, for example, may include three module groups in task execution container 14A and two module groups in task execution container 14B. In some implementation scenarios, even if two task execution containers contain the same number of module groups, the types of tasks handled by the module groups in the two task execution containers may be partially or completely different. For example, Figure 1B The task execution container 14C may include two module groups, while the two module groups included in the task execution container 14B may be a component task module group and a page rendering module, and the two module groups included in the task execution container 14C may be a page update module and a page rendering module.

[0060] In some embodiments, when any task execution container contains at least two module groups, these at least two module groups can execute their corresponding task steps independently. Based on this, the task configuration intelligent module transmits the natural language instructions of the task to be executed to the task execution container corresponding to the task. This enables the task configuration intelligent module to define the task type of the task content to be executed in the natural language instructions, and then send the natural language instructions to the module group in the task execution container that matches the task type.

[0061] Different module groups have different functions, and in some implementation scenarios, the number of intelligent modules included in different module groups can also vary. For example, a component task module group can contain multiple intelligent modules that collaborate to execute component tasks. A page update module can include one intelligent module that performs page update-related tasks by calling the D2C engine. A page rendering module can include one intelligent module that performs page rendering-related tasks by calling the UI engine.

[0062] The following examples of several task types illustrate the process of different module groups executing their corresponding tasks.

[0063] The module group matching the task type is the component task module group. The component task module group may include, for example, a component planning module and multiple component invocation modules. If the task type of the task content is component invocation, the task execution container can invoke the component planning module in the component task module group to parse the natural language instructions and obtain multiple component invocation subtasks; according to the execution flow of the multiple component invocation subtasks, it invokes each component invocation module in the component task module group to execute the corresponding subtask.

[0064] In some embodiments, the component planning module can receive natural language instructions from the task configuration intelligence module. Then, the component planning module can parse the natural language instructions to understand the multiple components involved, determine the subtasks for calling each component, and then determine the calling order of the multiple components based on the intent represented by the natural language instructions. Correspondingly, it determines the calling steps for calling the subtasks of each component according to the calling order, thus obtaining the execution flow of the multiple component calling subtasks. Afterwards, the component planning module can assign the subtask corresponding to the first step to the corresponding component calling module to trigger the corresponding component calling module to execute the corresponding subtask.

[0065] For example, given an exemplary natural language instruction, the component planning module can parse the form component, table component, and merge component involved in the instruction by understanding it. Then, the component planning module can generate component call subtasks for each component and determine the calling order of each component. For example, the calling order is form component -> table component -> merge component. Correspondingly, the execution flow of the component call subtasks can be "call form component -> call table component -> call merge component". Furthermore, the component planning module can first assign the subtask "call form component" to the form component intelligent module to trigger the form component intelligent module to call the form component in the browser.

[0066] In some embodiments, the component task module group may also include a process monitoring module. The process monitoring module is used to monitor the execution results of the subtasks at each step, and to analyze the execution results of the subtasks at the current step in real time, thereby detecting whether execution errors have occurred or whether adjustments such as inserting other parameters are needed. In this way, by setting the process monitoring module to monitor the execution results of each subtask in real time, and to dynamically adjust unexecuted subtasks based on the execution results, the fault tolerance rate of task execution is improved.

[0067] For example, for any subtask in a step, where the subtask is a pending execution subtask, the process monitoring module can detect whether the execution of the subtask depends on historical execution results. If the execution of the subtask depends on historical execution results, the process monitoring module can obtain those historical execution results. If the historical execution results are obtained, the prompt for the subtask is modified based on them to adjust the execution logic of the subtask. Then, the modified prompt is transmitted to the component invocation module corresponding to the subtask. If the historical execution results are not obtained, it can be determined that the subtask cannot be executed. The process monitoring module can then insert a new subtask before the step and transmit the new subtask to the component invocation module corresponding to the new subtask.

[0068] In this context, historical execution results can refer to the execution results of tasks preceding the current subtask. For example, if the subtask is a subtask of the first step in the execution flow, the historical execution results can be the execution results of other tasks preceding the subtask to be executed. If the subtask is not a subtask of the first step in the execution flow, the historical execution results can include the execution results of subtasks of at least one step preceding this step.

[0069] In some embodiments, the new subtask can be a subtask of the previous step of the current subtask, or it can be a subtask that retrieves the corresponding historical execution result. For example, the process monitoring module can receive return information indicating that historical execution results have been retrieved. If the return information indicating that historical execution results have not been retrieved indicates an error, the new subtask can be a subtask of the previous step of the current subtask; if the return information indicating that historical execution results have not been retrieved indicates that there are no historical execution results, the new subtask can be a subtask that retrieves the corresponding historical execution result.

[0070] As can be seen, by adopting this implementation method and setting up a process supervision module to monitor the execution status of each subtask to be executed, it is beneficial to dynamically plan the subtasks to be executed based on their real-time execution status. Errors can be blocked through re-execution mechanisms, and the completion rate of subtasks can be ensured by inserting tasks.

[0071] In some embodiments, for any step's subtask, the process monitoring module can also detect whether the step is the first step in the execution flow. If the step is the first step in the execution flow, the step of detecting whether the execution of the subtask of that step depends on historical execution results is performed. If the step is not the first step in the execution flow, after obtaining the execution result of the subtask, the execution result of the subtask of that step can be converted into result text and stored as historical execution results for retrieval as needed during the execution of subsequent tasks.

[0072] For example, the process monitoring module can monitor the execution status of subtasks in each step and plan the execution information of subtasks in the next step based on pre-deployed monitoring prompts. The guidance logic of the monitoring prompts is as follows: 1. Understand the division of labor and specific capabilities of each component calling module, and ensure that each component calling module executes tasks in the order of the subtask process.

[0073] 2. Based on the planned follow-up execution steps, the next execution step is obtained.

[0074] 3. Based on user questions, the planned content of the next step, the component's module calling capabilities, and the execution status of historical steps, the specific content of the next execution step can be replanned and revised, and the components to be used can be specified and the parameters required for component calling can be extracted.

[0075] 4. When a user provides page images and component images, the system can identify the position of each component image within the page image, generate each component schema in order from top to bottom and from left to right, add the component schema to a specific position in the page-level schema, and render the latest page-level schema onto the page.

[0076] 5. When there are no further steps to be executed (all steps have been completed), the process ends.

[0077] 6. Returns the result in a JSON structure.

[0078] For any component invocation module, after receiving a subtask, it can construct the corresponding component's data structure description information, i.e., the component schema. The component schema only contains the parameter structure of the invoked component and does not include the parameter values. Based on this, in response to receiving the corresponding component's invocation parameters, it generates a component invocation instruction based on the data structure description information and the invocation parameters. Based on the invocation instruction, it invokes the corresponding component to execute the subtask and obtains the execution result of the subtask.

[0079] For example, after a component calls a module to build a component schema, the component schema can be displayed on the UI so that developers can enter the calling parameters for the component.

[0080] The module group in the task execution container that matches the page update is the page update module. If the task type of the task content to be executed is page update, the task execution container can call the page update module to construct the data structure description information of the page before the update, as the first data structure description information. Then, it reads the data structure description information of the components contained in the natural language instruction, as the second data structure description information, and inserts the second data structure description information into the first data structure description information to obtain the data structure description information of the updated page.

[0081] For example, the first data structure description information may be the schema of the page, while the second data structure description information may be the component schema of the component to be displayed in the updated page.

[0082] Combination Figure 1AThe functional layers illustrated in the diagram allow the page update module to, for example, call the page building components in the component layer to construct the page's schema. Then, it can call the schema assembly engine in the engine layer to insert the component schema into the page's schema, obtaining the updated page's data structure description information. In some optional examples, after obtaining the updated page's data structure description information, the page update module can also call the schema engineering completion component in the component layer to automatically supplement or correct the page's data structure description information, thus obtaining the complete page information after the update.

[0083] The module group in the task execution container that matches page rendering is the page rendering module. If the task type of the task content to be executed is page rendering, the task execution container can call the page rendering module to read the data structure description information of the page to be rendered from the natural language instructions; and call the rendering tool to render the page according to the data structure description information of the page to be rendered.

[0084] Combination Figure 1A The functional layer shown in the diagram includes a page rendering module, which can call the UI engine in the engine layer to render the page based on the data structure description information of the page to be rendered.

[0085] Since the schemas in the above examples are all parameter structures, the components and engine in the task execution system can transmit only the parameter structure without transmitting the complete tokens. Compared with the conventional component calls that transmit complete tokens as call parameters, the use of this technical solution to transmit parameter structures can reduce a large proportion of data transmission, thereby reducing the API call overhead between intelligent modules and components.

[0086] The task execution method of this application embodiment is described below with reference to optional examples.

[0087] In the following embodiments, the task identification intelligence module is implemented as a coordinator agent, the task decomposition intelligence module is implemented as a planner agent, the task configuration intelligence module is implemented as a supervisor agent, and any task execution container includes, for example, a component team, a page schema agent, and an engine agent. The component team includes, for example, a component planner agent, a component supervisor agent, and multiple component invocation agents.

[0088] For example, the data flow of the agents collaborating to perform tasks can be as follows: Figure 3A As shown. During task execution, the data flow of each Agent includes the following steps: Step S31: After receiving the task description instruction input by the user, the coordinator Agent determines whether the task description instruction is related to the low-code page building task; if yes, proceed to step S32; if no, proceed to step S33.

[0089] The coordinator (Agent) receives task description instructions from the user through controls in the GUI. The GUI can be configured as follows: Figure 4A As shown.

[0090] Step S32: Transmit the task description instruction to the planner (Agent).

[0091] Step S33: Generate and output the response information.

[0092] Step S34: The planner agent extracts the image specified in the task description instruction; if the image is extracted, proceed to step S35; if the image is not extracted, proceed to step S36.

[0093] Step S35: Use the image slicing tool to slice the image and obtain multiple component images.

[0094] Step S36: Generate multiple tasks to be executed and transmit the multiple tasks to the supervisor Agent.

[0095] It should be understood that the planner agent generates multiple tasks to be executed by understanding the intent of the task description instructions. In some embodiments, if the planner agent needs to obtain other information from the user during the process of understanding the intent of the task description instructions, it can have more conversations with the user through the GUI until multiple tasks to be executed are generated.

[0096] In step S37, the supervisor agent configures multiple tasks to be executed into the task queues of the corresponding task execution containers.

[0097] Step S38: For any task execution container, determine whether the task execution container is idle; if yes, proceed to step S39; if no, proceed to step S310.

[0098] Step S39: Assign the corresponding task to be executed to the task execution container.

[0099] In some embodiments, if the Agent executing the task in the task execution container is a Page Schema Agent or an Engine Agent, the Agent executing the task calls the required components or engine to execute the task. If the Agent executing the task in the task execution container is a component team, the interaction process of each Agent during the execution of the task by the component team can be referred to... Figure 3B The example shown.

[0100] Step S310: Detect the execution status of the current task and obtain the execution result after the task is completed.

[0101] The planner agent can execute steps S34 to S36 based on the first prompt information, which can be implemented as follows: 1. Understand the division of labor among members in the task execution container pool and the available tools and capabilities.

[0102] 2. Understanding user questions: When users provide materials such as pictures, we analyze the user's intent by combining the materials with the user's questions.

[0103] When a user provides page images and component images, you can identify the position of each component image in the page image, and plan the generation order of each component schema from top to bottom and from left to right, the position of the component schema in the page-level schema, and the steps to render the latest page-level schema to the page.

[0104] 3. Based on the capabilities of the members in the task execution container pool, the user problem is broken down into a list of specific executable task steps, each step corresponding to a task to be executed by a task execution container.

[0105] The plan will be an array, and each array element contains a member field indicating the name of the task execution container, a task field indicating the task content, an imgUrl field indicating the image address required for task execution, and an apiUrl field indicating the API address required for task execution.

[0106] 4. After completing the planning, check whether each step is continuous and ensure that the parameters required for each step can be obtained from the historical execution results. If not, please replan the steps.

[0107] 5. Once the steps are planned, the execution flow will be handed over to the task coordination expert (supervisor, also known as the supervisor agent) for scheduling. The supervisor will be written to the next field. Only when you believe that the supervisor agent cannot resolve the issue will you return an empty array and write end to the next field. If you need additional information from the user, write human to the next field and write the corresponding additional parameters to the result field.

[0108] 6. Returns the result in a JSON structure.

[0109] rule: 1. Each step is an independent task. Please ensure that the task description (task) contains all the information required to execute this step. Please check to ensure that each step is executable. If a step requires tool parameters that depend on the result of a member's tool call, please add that member's tool call before this step.

[0110] 2. When planning, avoid adding redundant steps or skipping steps. The result of the last step should provide the final answer.

[0111] 3. Add a natural language description of the task content to the value of the task field, and the specific call format can be expressed using function format.

[0112] 4. If the image has special cell styles, such as multiple display fields, image display, or special color display, please remember to call the relevant cell generation method when planning.

[0113] 5. Avoid calling multiple tools in a single step; ensure that each step calls only one tool.

[0114] Figure 3B The signaling interaction diagram of the exemplary task execution method provided in the embodiments of this application illustrates an exemplary interaction process of a component team executing a task to be executed. The process of the component team executing the task to be executed includes the following steps: In step S320, the component planner agent receives the tasks to be executed from the supervisor agent, decomposes the tasks to be executed according to the functions of each component calling the agent, obtains multiple sub-tasks, and determines the steps between the multiple sub-tasks.

[0115] Step S321: Send the plurality of subtasks and the steps between the plurality of subtasks to the component supervisor Agent.

[0116] In step S330, the component supervisor Agent determines the subtask of the current step to be executed and determines whether there is an execution result of the previous step of the current step to be executed; if yes, proceed to step S331; if no, proceed to step S332.

[0117] Step S331: Convert the execution result of the previous step into natural language and output it.

[0118] Step S332: Determine whether the execution of the subtask of the current step depends on the historical execution result; if yes, execute step S333; if no, execute step S335.

[0119] In this example, the current step to be executed is the first step.

[0120] Step S333: Obtain the historical execution results. If the result is obtained successfully, proceed to step S334; if the result is obtained unsuccessfully, proceed to step S337.

[0121] Step S334: Update the prompt words of the subtask of the current step to be executed based on the obtained historical execution results.

[0122] Step S335: Send the prompt word of the subtask of the current step to be executed to the component calling agent corresponding to the subtask, so that the component calling agent executes the subtask according to steps S340 to S342.

[0123] Step S336: After the corresponding component calls the Agent to execute the subtask, step S330 is executed again.

[0124] Step S337: Insert a new subtask before the subtask of the current step to be executed, and treat the new subtask as the new subtask of the current step to be executed. Then execute step S335.

[0125] Step S340: The component calls the Agent to build the corresponding component schema.

[0126] Step S341: Output the component schema to receive the parameter values ​​corresponding to the component schema.

[0127] The component schema can be displayed to the user to receive parameter values ​​input by the user. The GUI displayed by the component schema can be shown in Figure 4.

[0128] Step S342: Invoke the corresponding component based on the call parameters consisting of the component schema and parameter values.

[0129] As can be seen from the descriptions of the foregoing embodiments, during the process of the agents collaborating to execute development tasks, the GUI corresponding to the task execution system can be continuously updated as the development tasks are executed. Furthermore, during the stages of process integration, such as refining the schema, the GUI interacts with the user to ensure the execution of the development tasks.

[0130] like Figures 4A to 4C As shown, the GUI update process is illustrated using a page building task as an example. Figure 4AThis illustrates an exemplary GUI for a user input page to build a request. The GUI may include a request information input area 411, an Agent dialog box 412, and a user avatar icon 413. The request information input area 411 can be implemented as an image input control, which can link to a local image library for the user to select an image to input. For example, this control may display a default "placeholder text" to indicate its function. The Agent dialog box 412 can be the area where the user interacts with the Agent. In response to the user's request, the Agent's dialog box and the user's natural language commands can be displayed in this area (e.g., ...). Figure 4B and Figure 4C (As shown in the schematic GUI). For example, a user can input task execution instructions into the coordinator Agent by dragging and dropping information related to the task execution instructions into the Agent dialog box 412. The user avatar icon 413 can be a plugin icon for the Agent. In response to the user's triggering operation on the user avatar icon 413, the Agent dialog box 412 can display the interface where the Agent is invoked. Figure 4A The GUI has been updated to Figure 4B The GUI shown.

[0131] Figure 4B This illustrates an exemplary GUI for invoking Agent functionality. The GUI may include a sidebar 420, which displays the Agent's user avatar icon 421, username 422, and a function description 423. Upon receiving a task execution command from the user, the sidebar 420 can trigger the Agent to execute development tasks. Figure 4B The GUI has been updated to Figure 4C The GUI shown.

[0132] Figure 4C An exemplary GUI is shown during the agent's task execution process. In this GUI, the sidebar 420 can display the agent's execution progress and dialogue information in the form of a dialog.

[0133] It should be understood that Figures 4A to 4C The illustrated GUI is for illustrative purposes only and does not constitute a limitation on the embodiments of this application. In the embodiments of this application, the GUI may display different interface elements and content than those shown in the illustration, depending on the type of task and the role type of the Agent. No limitations are imposed here.

[0134] In summary, the technical solution of this application receives task instruction information for the target development task. Then, it calls the task decomposition intelligent module to generate natural language instructions for multiple tasks to be executed. In other words, using this technical solution, developers can describe the development task by inputting text instructions such as task instruction information. The task decomposition intelligent module then decomposes the development task described by the text instructions into tasks to be executed, also described by text, and assigns these tasks to corresponding task execution containers for execution. Each task execution container also executes its corresponding task through the collaboration of multiple intelligent modules. Therefore, in this technical solution, developers can trigger multiple intelligent modules to automatically execute the development task by inputting the development task using natural language, eliminating the need for extensive manual code editing. This facilitates low-code front-end development, thereby improving development efficiency and lowering the professional threshold for front-end development. Furthermore, the collaboration of multiple intelligent modules to execute development tasks increases the automation level of front-end development, further improving development efficiency.

[0135] The above embodiments describe various implementations of the method provided in this application from the perspectives of generating natural language instructions for multiple tasks to be executed, calling a task execution container to execute the tasks to be executed, and adjusting the execution steps of subtasks. It should be understood that, corresponding to the above processing steps, the embodiments of this application can implement the above functions in hardware or a combination of hardware and computer software. Whether a function is executed by hardware or by computer software driving hardware depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0136] For example, if the above implementation steps are achieved through software modules to realize the corresponding functions. Figure 5 As shown, a task execution device is provided, which may include a generation module 511, a transmission module 512, and an execution module 513. This task execution device can be used to perform the aforementioned tasks. Figures 2 to 4C Some or all of the operations in the process.

[0137] For example: Generation module 511 is used to, in response to receiving task instruction information of the target development task, call the task decomposition intelligent module to generate natural language instructions for multiple tasks to be executed based on the task instruction information; Transmission module 512 is used to, for any task to be executed, call the task configuration intelligent module to transmit the natural language instructions of the task to be executed to the task execution container corresponding to the task to be executed, wherein the task execution container is any one of the preset task execution container pools, and any task execution container in the task execution container pool includes multiple execution intelligent modules; Execution module 513 is used to, for any task to be executed, call the multiple execution intelligent modules in the task execution container of the task to be executed to execute the task based on the corresponding natural language instructions.

[0138] Optionally, the generation module 511 is further configured to identify task features in the task instruction information, the task features including at least one of task description words and page images; parse the development intent of the target development task according to the task features; and generate natural language instructions for the plurality of tasks to be executed according to the development intent and the attributes of each task execution container in the task execution container pool, wherein the natural language instruction of any task to be executed includes a task execution container identifier, the content of the task to be executed, and a component call address.

[0139] Optionally, if the task features include a page image, and the page image includes a graphic of at least one development component, the generation module 511 is further configured to call an image segmentation tool to segment the page image to obtain at least one development component image block, each development component image block containing a graphic of a development component; extract the semantic features of the at least one development component image block respectively; and determine the development intent of the target development task based on the task description words and the semantic features of each development component image block.

[0140] Optionally, the task execution device further includes a detection module, which is used to detect whether the task execution containers of the plurality of tasks to be executed are all idle. The execution module 513 is used to call the task execution containers of the plurality of tasks to be executed to execute the corresponding tasks in parallel when the task execution containers of the plurality of tasks to be executed are all idle.

[0141] Optionally, any task execution container may contain multiple intelligent modules corresponding to at least one module group, and the at least one module group may be used to execute tasks of different task types. The execution module 513 may also be used to determine the task type of the task content to be executed in the natural language instruction and send the natural language instruction to the module group in the task execution container that matches the task type.

[0142] Optionally, the task type of the task content is component invocation, and the module group matching the task type is component task module group. The execution module 513 is also used to call the component planning module in the component task module group, parse the natural language instructions to obtain multiple component invocation subtasks, and call each component invocation module in the component task module group to execute the corresponding subtask according to the execution flow of the multiple component invocation subtasks.

[0143] Optionally, the execution module 513 is further configured to, for any step's subtask, if the execution of the subtask depends on historical execution results, call the process supervision module to obtain the historical execution results; if the historical execution results are obtained, modify the prompt word of the subtask according to the historical execution results, and transmit the modified prompt word to the component invocation module corresponding to the subtask; if the historical execution results are not obtained, insert a new subtask before the step, and transmit the new subtask to the component invocation module corresponding to the new subtask.

[0144] Optionally, the execution module 513 is further configured to detect whether the step is the first step in the execution process; if the step is the first step in the execution process, detect whether the execution of the subtask of the step depends on the historical execution result; if the step is not the first step in the execution process, after obtaining the execution result of the subtask, convert the execution result of the subtask of the step into result text.

[0145] Optionally, the execution module 513 is further configured to call the component invocation module to construct the data structure description information of the corresponding component; in response to receiving the invocation parameters of the corresponding component, generate a component invocation instruction based on the data structure description information and the invocation parameters; invoke the corresponding component to execute the subtask based on the invocation instruction, and obtain the execution result of the subtask.

[0146] Optionally, the task type of the task content is page update, and the module group matching the task type is the page update module. The execution module 513 is also used to construct the data structure description information of the page before the update as the first data structure description information; read the data structure description information of the components contained in the natural language instruction as the second data structure description information; and insert the second data structure description information into the first data structure description information to obtain the data structure description information of the page after the update.

[0147] Optionally, the task type of the task content is page rendering, and the module group matching the task type is the page rendering module. The execution module 513 is further used to call the page rendering module to read the data structure description information of the page to be rendered from the natural language instructions; and to call the rendering tool to render the page according to the data structure description information of the page to be rendered.

[0148] Optionally, the task execution device further includes an output module. The detection module is further configured to, in response to receiving an initial natural language instruction, invoke the task recognition intelligent module to detect whether the initial natural language instruction contains task features; the transmission module 512 is further configured to, if it does, transmit the initial natural language instruction as the task instruction information to the task decomposition intelligent module; the output module is configured to, if it does not contain task features, output response information to the initial natural language instruction.

[0149] It is understandable that the above division of modules is only a logical functional division. In actual implementation, the functions of the above modules can be integrated into hardware entities. For example, the function of the transmission module 512 can be integrated into the transceiver, and the functions of the generation module 511 and the execution module 513 can be integrated into the processor, etc.

[0150] Please refer to Figure 6 , Figure 6 An electronic device 6 is provided, which can be implemented as carrying Figure 1A This is a device for a task execution system. The electronic device may include a processor 61, a transceiver 62, and a memory 63, these components being connected and communicating via a communication bus 64. The transceiver 62 can be used for communication to transmit various types of natural language execution and data related to the task. The memory 63 is used to store computer programs and data generated during task execution; when the computer program is invoked, it causes the processor 61 to execute the aforementioned... Figures 2 to 4C The operation of some or all of the electronic devices.

[0151] For details on the implementation process, please refer to [link / reference]. Figures 2 to 4C The relevant descriptions are omitted here.

[0152] It should be understood that, in some feasible implementations, Figure 6The processor illustrated can be a central processing unit (CPU), but it can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor can be a microprocessor or any conventional processor. Figure 6 The memory illustrated may include read-only memory and random access memory, and provides instructions and data to the processor. A portion of the memory may also include non-volatile random access memory. For example, the memory may also store information such as the device type.

[0153] This application also provides a computer-readable storage medium storing image processing instructions, which, when executed on a computer, cause the computer to perform the aforementioned actions. Figures 2 to 4C Some or all of the steps in the method described in the illustrated embodiments.

[0154] This application also provides a computer program product including instructions for task execution, which, when run on a computer, causes the computer to perform the aforementioned... Figures 2 to 4C Some or all of the steps in the method described in the illustrated embodiments.

[0155] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0156] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection between apparatuses or units through some interfaces, and may be electrical, mechanical, or other forms.

[0157] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0158] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0159] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, smartphone, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0160] Although alternative embodiments of this application have been described, those skilled in the art, upon learning the basic inventive concept, can make further changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of this application.

[0161] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of this application. It should be understood that the above description is only a specific embodiment of this application and is not intended to limit the scope of protection of this application. Any modifications, equivalent substitutions, improvements, etc., made on the basis of the technical solution of this application should be included within the scope of protection of this invention.

Claims

1. A task execution method, characterized in that, The method includes: In response to receiving the task instruction information for the target development task, the task decomposition intelligent module is invoked to generate natural language instructions for multiple tasks to be executed based on the task instruction information; For any task to be executed, the task configuration intelligent module is invoked to transmit the natural language instructions of the task to be executed to the task execution container corresponding to the task. The task execution container is any one of the preset task execution container pools, and any task execution container in the task execution container pool includes multiple execution intelligent modules. For any task to be executed, multiple execution intelligence modules in the task execution container of the task to be executed are invoked to execute the task based on the corresponding natural language instructions.

2. The method according to claim 1, characterized in that, The task decomposition intelligent module generates natural language instructions for multiple tasks to be executed based on the task indication information, including: Identify task features in the task instruction information, wherein the task features include at least one of task description words and page images; The development intent of the target development task is analyzed based on the task characteristics described. Based on the development intent and the attributes of each task execution container in the task execution container pool, natural language instructions for the multiple tasks to be executed are generated. The natural language instructions for any task to be executed include the task execution container identifier, the content of the task to be executed, and the component call address.

3. The method according to claim 1, characterized in that, When the task features include a page image, and the page image includes a graphic of at least one development component, the step of parsing the development intent of the target development task based on the task features includes: The page image is segmented using an image segmentation tool to obtain at least one development component image block, and each development component image block contains a graphic of a development component. Extract the semantic features of each of the at least one development component image blocks; The development intent of the target development task is determined based on the semantic features of the task description words and the image blocks of each development component.

4. The method according to any one of claims 1-3, characterized in that, After, for any task to be executed, the task configuration intelligence module is invoked to transmit the natural language instructions of the task to be executed to the task execution container corresponding to the task, the process further includes: Check whether all task execution containers of the multiple tasks to be executed are idle; When all the task execution containers of the multiple tasks to be executed are idle, the task execution containers of the multiple tasks to be executed are invoked to execute the corresponding tasks in parallel.

5. The method according to claim 4, characterized in that, Each task execution container contains multiple intelligent modules corresponding to at least one module group. The at least one module group is used to execute tasks of different task types. The task configuration intelligent module transmits the natural language instructions of the task to be executed to the task execution container corresponding to the task to be executed, including: Determine the task type of the task content to be executed in the natural language instruction; The natural language instruction is sent to the module group in the task execution container that matches the task type.

6. The method according to claim 5, characterized in that, The task type of the task content is component invocation, and the module group matching the task type is the component task module group. Multiple intelligent execution modules in the task execution container that invokes the task to be executed execute the task based on corresponding natural language instructions, including: The component planning module in the component task module group is invoked to parse the natural language instructions and obtain multiple component invocation subtasks. According to the execution flow of the multiple component calling subtasks, each component calling module in the component task module group is called to execute the corresponding subtask.

7. The method according to claim 6, characterized in that, The step of calling each component calling module in the component task module group to execute the corresponding subtask according to the execution flow of the multiple component calling subtasks includes: For any subtask of a step, if the execution of the subtask depends on the historical execution result, the process supervision module is invoked to obtain the historical execution result; If the historical execution result is obtained, the prompt word of the subtask is modified according to the historical execution result, and the modified prompt word is transmitted to the component calling module corresponding to the subtask; If the historical execution result is not obtained, a new subtask is inserted before the step, and the new subtask is transmitted to the component calling module corresponding to the new subtask.

8. The method according to claim 7, characterized in that, Also includes: Detect whether the step is the first step in the execution flow; If the step is the first step in the execution flow, detect whether the execution of the subtask of the step depends on the historical execution result; If the step is not the first step in the execution flow, after obtaining the execution result of the subtask, the execution result of the subtask of the step is converted into result text.

9. The method according to any one of claims 6-8, characterized in that, For any component calling module, the step of calling each component calling module in the component task module group to execute the corresponding subtask includes: The component invokes the module to construct the corresponding component's data structure description information; In response to receiving the call parameters of the corresponding component, a component call instruction is generated based on the data structure description information and the call parameters; The corresponding component is invoked based on the invocation instruction to execute the subtask, and the execution result of the subtask is obtained.

10. The method according to claim 5, characterized in that, The task type of the task content is page update, and the module group matching the task type is the page update module. Multiple intelligent execution modules in the task execution container that invokes the task to be executed execute the task based on corresponding natural language instructions, including: The data structure description information of the page before the update is constructed, which serves as the first data structure description information; Read the data structure description information of the components contained in the natural language instruction, and use it as the second data structure description information; The second data structure description information is inserted into the first data structure description information to obtain the updated page's data structure description information.

11. The method according to claim 5, characterized in that, The task type of the task content is page rendering, and the module group matching the task type is the page rendering module. Multiple intelligent execution modules in the task execution container that invokes the task to be executed execute the task based on corresponding natural language instructions, including: The page rendering module is invoked to read the data structure description information of the page to be rendered from the natural language instructions; The rendering tool is invoked to render the page based on the data structure description information of the page to be rendered.

12. The method according to claim 1, characterized in that, Also includes: In response to receiving an initial natural language instruction, the task recognition intelligent module is invoked to detect whether the initial natural language instruction contains task features; If included, the initial natural language instruction is transmitted to the task decomposition intelligent module as the task instruction information; If not included, output the response information to the initial natural language instruction.

13. A task execution system, characterized in that, The system includes a task decomposition intelligent module, a task configuration intelligent module, and a task execution container pool. Each task execution container in the task execution container pool includes multiple execution intelligent modules. The task decomposition intelligent module is used to generate natural language instructions for multiple tasks to be executed based on the task instruction information received from the target development task. The task configuration intelligent module is used to transmit the natural language instructions of any task to be executed to the task execution container corresponding to the task to be executed. The task execution container is any one of the preset task execution container pool. Any task execution container is used to invoke multiple execution intelligence modules to execute the task to be executed based on corresponding natural language instructions.

14. A task execution device, characterized in that, The device includes: The generation module is used to respond to the received task instruction information of the target development task and call the task decomposition intelligent module to generate natural language instructions for multiple tasks to be executed based on the task instruction information. The transmission module is used to call the task configuration intelligence module to transmit the natural language instructions of the task to be executed to the task execution container corresponding to the task, for any task to be executed. The task execution container is any one of the preset task execution container pools, and any task execution container in the task execution container pool includes multiple execution intelligence modules. The execution module is used to invoke multiple intelligent execution modules in the task execution container of any task to be executed to execute the task based on corresponding natural language instructions.

15. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, The processor executes the program to implement the method as described in any one of claims 1-12.

16. A computer-readable storage medium having a computer program stored thereon, characterized in that, The program is executed by a processor to implement the method as described in any one of claims 1-12.

17. A computer program product, comprising a computer program, characterized in that, The computer program is executed by a processor to implement the method according to any one of claims 1-12.

Images