Interactive task processing method and device, equipment and storage medium

Abstract

The application relates to the technical field of model interaction, and discloses an interactive task processing method and device, equipment and a storage medium, which comprise the following steps: in response to a natural language instruction input by a user, calling an intelligent agent to construct a corresponding target workflow; adjusting the arrangement order of skill nodes, and dividing the adjusted target workflow into multiple sub-processes to obtain a target execution plan; and according to the target execution plan, calling a preset execution agent to execute the skill nodes to obtain an execution result of the target workflow. The intelligent agent automatically constructs the target workflow, and in the process of dynamically optimizing the target workflow and dividing the sub-processes, the arrangement order of the skill nodes is adjusted and optimized in a global range, so that the local sub-processes can be independently adjusted without reconstructing the entire workflow during the execution process, and the high stability of the workflow execution and the flexible response capability to the user interaction instruction are considered.

Description

Technical Field

[0001] This application relates to the field of model interaction technology, and in particular to an interactive task processing method, apparatus, device and storage medium. Background Technology

[0002] Currently, in responding to users' natural language commands to automate task processing, both single AI agent-based conversational decision engines and rule-based workflow engines require deep human involvement in the workflow configuration, orchestration, and debugging process. This results in low efficiency in converting natural language commands into executable tasks, making it difficult to meet the requirements of business scenarios for automation and execution efficiency. Summary of the Invention

[0003] The main objective of this application is to provide an interactive task processing method, apparatus, device, and storage medium, which aims to solve the technical problem that it is difficult to meet the requirements of business scenarios for automation level and execution efficiency in responding to users' natural language commands to achieve automated task processing.

[0004] To achieve the above objectives, this application proposes an interactive task processing method, the method comprising: In response to a natural language command input by the user, an intelligent agent is invoked to construct a corresponding target workflow, wherein the target workflow includes multiple skill nodes arranged in an orchestrated order; The arrangement order of the skill nodes is adjusted, and the adjusted target workflow is divided into multiple sub-processes to obtain the target execution plan; According to the target execution plan, the preset execution agent is invoked to execute the skill node, and the execution result of the target workflow is obtained.

[0005] Optionally, the intelligent agent includes a supervisory agent, an orchestration agent, and a filling agent; the invoking of the intelligent agent to construct the corresponding target workflow includes: Based on contextual instructions, the supervisory agent parses the natural language instructions to generate a task plan; Based on the task planning, candidate skills are selected from the preset skill library through the orchestration agent, and the candidate skills are arranged in the logical order of the task planning to generate a workflow to be filled. The filling agent extracts parameter values ​​from the natural language instructions and uses these parameter values ​​to fill metadata in the skill nodes of the workflow to be filled, thereby generating the target workflow.

[0006] Optionally, the step of selecting candidate skills from a preset skill library based on the task planning, and arranging the candidate skills according to the logical order of the task planning to generate a workflow to be populated, includes: Based on the orchestration agent, the semantic similarity between the task planning and the descriptions of each skill in the preset skill library is calculated, and candidate skills are selected from the preset skill library according to the semantic similarity. The task plan and the candidate skills are input into a preset orchestration model. The orchestration model generates a logical calling order for the candidate skills to obtain a workflow to be filled. The logical calling order is used to determine the relative position of each candidate skill in the workflow to be filled.

[0007] Optionally, adjusting the arrangement order of the skill nodes and dividing the adjusted target workflow into multiple sub-processes to obtain the target execution plan includes: Based on the dependencies between skill nodes in the target workflow, the earliest start time and the latest start time of each skill node are determined, and the skill node whose earliest start time is equal to the latest start time is determined as the critical skill node. Determine key skill paths based on the key skill nodes; The arrangement order of each skill node is adjusted based on the key skill path to obtain an optimized arrangement order; Based on the optimized arrangement order, the target workflow is divided into multiple sub-processes, and the sub-processes are dynamically planned locally according to the user's intent to obtain the target execution plan.

[0008] Optionally, adjusting the arrangement order of each skill node based on the key skill path to obtain an optimized arrangement order includes: Based on the aforementioned key skill paths, determine the time difference between each key skill node at the current level and the previous level; When the time difference is greater than a preset time threshold, the key skill node is moved up to the next higher level; The optimized arrangement order is determined based on the adjusted key skill nodes.

[0009] Optionally, the step of performing local dynamic programming on the sub-processes according to user intent to obtain the target execution plan includes: Obtain user intent from user feedback and determine the similarity score corresponding to the user intent; Based on the similarity score, a hierarchical search is performed from top to bottom in the retrieval enhancement generation hierarchy architecture to obtain a set of target tags that match the user intent; Based on the target label set, the intelligent agent is invoked to perform local dynamic planning within the sub-processes corresponding to the sub-process hierarchical labels, thereby generating the target execution plan.

[0010] Optionally, the step of invoking a preset execution agent to execute the skill node according to the target execution plan, and obtaining the execution result of the target workflow, includes: The communication protocol corresponding to the skill node is identified through the protocol adaptation layer of the preset execution agent, and the communication protocol is converted into the target protocol format. The unified identity authentication token is exchanged for an access token for the heterogeneous service corresponding to the skill node through the permission verification layer of the preset execution agent. The execution result of the target workflow is obtained by invoking the heterogeneous service through the skill execution layer of the preset execution agent based on the target protocol format and the access token.

[0011] Furthermore, to achieve the above objectives, this application also proposes an interactive task processing device, which includes: A construction module is used to respond to natural language commands input by the user and call the intelligent agent to construct the corresponding target workflow, wherein the target workflow includes multiple skill nodes arranged in an orchestration order; The scheduling module is used to adjust the arrangement order of the skill nodes and divide the adjusted target workflow into multiple sub-processes to obtain the target execution plan; The execution module is used to call a preset execution agent to execute the skill node according to the target execution plan, so as to obtain the execution result of the target workflow.

[0012] In addition, to achieve the above objectives, this application also proposes an interactive task processing device, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the interactive task processing method as described above.

[0013] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and which, when executed by a processor, implements the steps of the interactive task processing method described above.

[0014] In this application, an intelligent agent is invoked to automatically construct the target workflow. During the dynamic optimization and sub-process division of the target workflow, the arrangement order of skill nodes is adjusted and optimized globally. This allows for independent adjustments to local sub-processes during execution without reconstructing the entire workflow. This balances high stability of workflow execution with flexible response to user interaction commands, effectively solving the technical problem that a single decision engine cannot simultaneously guarantee execution stability and interaction flexibility. Attached Figure Description

[0015] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0016] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is a flowchart illustrating the first embodiment of the interactive task processing method of this application; Figure 2 System architecture diagram of the digital LUI base used in the interactive task processing method of this application; Figure 3 This is a flowchart illustrating the second embodiment of the interactive task processing method of this application; Figure 4 This is a framework diagram of the multi-agent system in this application; Figure 5 This is a flowchart illustrating the third embodiment of the interactive task processing method of this application; Figure 6 This is a flowchart of the heuristic dynamic hierarchy adjustment algorithm of this application; Figure 7 This is a flowchart of the runtime self-limiting dynamic programming method in this application; Figure 8 This is a flowchart illustrating the fourth embodiment of the interactive task processing method of this application; Figure 9 A flowchart for the proxy execution of the skills required for this application; Figure 10 This is a schematic diagram of the module structure of the interactive task processing device according to an embodiment of this application; Figure 11 This is a schematic diagram of the device structure of the hardware operating environment involved in the interactive task processing method in the embodiments of this application.

[0018] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0019] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0020] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0021] With the rapid development of large language model technology, Language User Interface (LUI) has gradually become an emerging interaction paradigm. Among related technologies, there are two main technical paths for responding to users' natural language commands to achieve automated task processing: one is a conversational decision engine based on AI agents, which can autonomously understand user intent and conduct multi-turn interactions, offering high flexibility but poor predictability and stability of execution logic; the other is a workflow engine based on fixed rules, which pre-arranges the logical order and dependencies of each execution step, exhibiting high determinism and execution stability, but lacking adaptability to dynamic interactions and real-time changes in user intent.

[0022] The two aforementioned technical approaches inherently present a contradiction between "stability" and "flexibility." When various business systems need to automate task processing based on natural language interaction, using a single conversational decision engine, while capable of flexibly responding to user commands, results in the workflow execution logic being dynamically generated based on user interaction. This uncertainty in the execution path makes it difficult for the system to guarantee stable output in critical business processes. Conversely, using a workflow engine with fixed rules, while offering predictable and controllable execution, relies on manual pre-configuration for workflow orchestration, making it impossible to dynamically adjust based on real-time user feedback and changes in intent, thus lacking interactive flexibility. Furthermore, both approaches require deep human involvement in the workflow configuration, orchestration, and debugging process, leading to low efficiency in converting natural language commands into executable tasks and failing to meet the automation and execution efficiency requirements of business scenarios.

[0023] Therefore, how to balance high stability of workflow execution and flexible response to user interaction commands in the process of automating tasks driven by natural language, while improving the efficiency of building automated task execution from natural language commands, is a technical problem that urgently needs to be solved.

[0024] Therefore, this application implements a general solution based on Agentic Workflow, with the core objectives of "automatic construction, stable execution, flexible scheduling, and zero-code deployment", to help various systems achieve end-to-end complete, accurate, and efficient deployment of new interaction methods.

[0025] It should be noted that the executing entity in this embodiment can be a computing service device with data processing, network communication, and program execution functions, such as a computer, or an electronic device capable of performing the above functions. The following description uses an interactive task processing system as an example to illustrate this embodiment and the subsequent embodiments.

[0026] Based on this, embodiments of this application provide an interactive task processing method, referring to... Figure 1 , Figure 1 This is a flowchart illustrating the first embodiment of the interactive task processing method of this application.

[0027] In this embodiment, the interactive task processing method includes: Step S10: In response to the natural language command input by the user, the intelligent agent is invoked to construct the corresponding target workflow, which includes multiple skill nodes arranged in an orchestration order.

[0028] It should be noted that natural language commands are text instructions input by the user in natural language form to describe the execution logic of the target task, such as "query this month's sales and generate a report to send to the department's email address." The target workflow is a structured executable process containing multiple skill nodes and their orchestration order. Each skill node corresponds to a minimum independently executable business operation unit (such as calling an API interface, performing a data query, or sending a message notification). The orchestration order of the skill nodes represents the sequential dependency relationship between the skill nodes in the execution sequence.

[0029] It is understandable that when calling on intelligent agents to construct a target workflow, multiple first intelligent agents with different functions can work together to complete the conversion from natural language instructions to structured workflow.

[0030] Specifically, the intelligent agent can include a supervisory agent, an orchestration agent, and a filling agent. First, the supervisory agent parses natural language instructions, understands user intent by combining contextual dialogue history, and generates a high-level task plan. This task plan includes several subtasks that need to be broken down into the target task and their logical relationships. Second, the orchestration agent recalls candidate skills that match the user intent from a preset skill library according to the task plan, and sorts the candidate skills according to the logical order indicated by the task plan, generating a workflow to be filled containing skill nodes but with empty metadata for each node. Finally, the filling agent extracts parameter values ​​from the natural language instructions and context, fills in complete metadata (such as input parameters, output format, timeout, and other configuration information) for each skill node in the workflow to be filled, generating an executable target workflow.

[0031] Optionally, the agent can be built based on a large language model and fine-tuned on a dataset specific to a business domain to improve the accuracy of understanding natural language instructions within the domain and the precision of workflow construction. Each skill in the preset skill library is pre-associated with a skill description text and a parameter template. The orchestration agent filters candidate skills by calculating the semantic similarity between the task plan and the skill description text, while the filling agent extracts the corresponding parameter values ​​from the natural language instructions based on the parameter template and fills them in.

[0032] Step S20: Adjust the arrangement order of the skill nodes and divide the adjusted target workflow into multiple sub-processes to obtain the target execution plan.

[0033] Understandably, based on preset optimization strategies, the execution sequence of each skill node in the target workflow can be reallocated to shorten the overall execution time of the workflow. Dividing the adjusted target workflow into multiple sub-processes can be achieved by segmenting the complete workflow into several independently executable process segments according to business logic boundaries or dependencies between skill nodes. Each sub-process contains at least one skill node; the target execution plan includes the final execution order of each skill node, the execution level, and the connection relationships between each sub-process.

[0034] Optionally, the timing of adjusting the above-mentioned orchestration order can be triggered after receiving a user interaction instruction, or it can be triggered automatically after the initial construction of the target workflow is completed. When the target workflow receives a user interaction instruction during execution, the target sub-process to which the interaction instruction points is first determined. Only local dynamic planning is performed within the target sub-process, while the original execution plans of the other sub-processes remain unchanged, thus balancing the stability of the overall workflow execution and the flexibility of local interactions.

[0035] Step S30: According to the target execution plan, call the preset execution agent to execute the skill node and obtain the execution result of the target workflow.

[0036] Understandably, the preset execution agent is a middleware module used to achieve unified scheduling and execution of skills across multiple business sectors. It supports access and invocation of various communication protocols, permission systems, and heterogeneous service types. When the preset execution agent is invoked to execute skill nodes according to the target execution plan, the preset execution agent is invoked sequentially or in parallel to execute each skill node according to the execution order and execution level specified in the target execution plan. The execution results of each skill node are aggregated and output as the final execution result of the target workflow.

[0037] Optionally, when executing multiple skill nodes in parallel, the default execution agent uses a thread pool or coroutine pool to control the number of concurrent calls, preventing overload of the target heterogeneous service due to excessive concurrency. The default execution agent is also configured with timeout control and retry mechanisms. When a skill node call fails to return a result after exceeding a preset time threshold, timeout processing logic is triggered. When a skill node call fails due to network jitter or temporary service unavailability, a limited number of retries are performed according to the preset retry strategy to improve the fault tolerance and success rate of workflow execution.

[0038] In one example, reference Figure 2 , Figure 2This is a system architecture diagram of the digital LUI base for the interactive task processing method applied in this application. The architecture is based on the core concept of Agentic Workflow, combining the static rules of traditional workflows with the autonomous decision-making capabilities of AI. With the interaction optimization of the ecosystem layer and the reuse of skills from multiple business sectors in the skill layer, an iterative and adaptive intelligent LUI base is ultimately constructed. This digital LUI foundation adopts a bottom-up five-layer architecture. The foundation layer provides underlying resources such as databases, search engines, basic large models, enterprise-level and domain-specific AI capabilities, and FaaS cloud services. The skill layer encapsulates reusable skills across multiple business scenarios, including API services, large model services, plugin services, function services, and Mock services, based on the capabilities of the foundation layer. The core layer, as the central hub of the entire foundation, includes a builder (based on a multi-agent framework to achieve skill orchestration, template lookup, and metadata population), a scheduler (based on self-limiting dynamic programming, a hierarchical tagging system, and the critical path method to achieve parallel routing fusion and pre-warm-up execution), and an executor (through layered decoupling and dynamic adaptation, unified scheduling and execution of skills is achieved through protocol adapters, permission verifiers, token exchange, and asynchronous task splitting mechanisms). Above the core layer, the access platform provides standardized access capabilities for users and front-end systems, such as a low-code card platform, speech recognition and intelligent error correction, one-click H5 publishing, and cross-canvas fusion proxy. The ecosystem layer, located at the top of the architecture, connects to various business systems within the industry, enabling the rapid implementation of conversational interaction in various business scenarios through the LUI foundation. The overall architecture is based on the three engines of core layer construction, scheduling and execution. It shields the heterogeneity of the foundation layer and skill layer from the bottom, and provides standardized delivery capabilities through the access platform. Ultimately, it realizes the reuse of skills in multiple industries and the automated construction, efficient scheduling and stable execution of conversational systems.

[0039] In this embodiment, the intelligent agent is invoked to automatically construct the target workflow. During the process of dynamically optimizing the target workflow and dividing it into sub-processes, the arrangement order of skill nodes is adjusted and optimized globally. This allows for independent adjustments to local sub-processes during execution without reconstructing the entire workflow. This balances the high stability of workflow execution with the flexible response to user interaction commands, effectively solving the technical problem that a single decision engine cannot simultaneously guarantee execution stability and interaction flexibility.

[0040] Reference Figure 3 , Figure 3 This is a flowchart illustrating the second embodiment of the interactive task processing method of this application. Based on the first embodiment described above, a second embodiment of the interactive task processing method of this application is proposed.

[0041] In the second embodiment, the intelligent agent includes a supervisory agent, an orchestration agent, and a filling agent; the invocation of the intelligent agent to construct the corresponding target workflow includes: Step S101: Based on the context instructions, the natural language instructions are parsed by the supervisory agent to generate a task plan.

[0042] In this embodiment, the contextual instruction is the natural language instruction entered by the user in the current round of dialogue, as well as the historical dialogue context information associated with the natural language instruction.

[0043] Understandably, the supervisory agent is responsible for understanding user intent, breaking down the problem, developing high-level plans, coordinating the work of the other two agents, and reviewing the work completed by the orchestration and population agents. The supervisory agent supports multi-turn dialogue with the user, combined with contextual understanding, to achieve dynamic task planning.

[0044] Specifically, upon receiving a natural language instruction, the supervisory agent first retrieves the historical dialogue rounds within the session containing the instruction. From these historical dialogues, it extracts previously confirmed user intents, completed sub-task information, and filled key parameters. This information is then concatenated with the current natural language instruction to form a complete contextual instruction sequence. Next, the supervisory agent inputs this contextual instruction sequence into a pre-built intent understanding model. The model identifies whether the current user intent is to initiate a new workflow construction task, modify or adjust an existing workflow, or intervene in a specific stage of the workflow execution. Based on the identified user intent type, the supervisory agent executes the corresponding task planning strategy.

[0045] Step S102: Based on the task planning, candidate skills are selected from the preset skill library through the orchestration agent, and the candidate skills are arranged in the logical order of the task planning to generate a workflow to be filled.

[0046] In this embodiment, the orchestration agent is an agent module in the multi-agent framework responsible for matching suitable skills from a preset skill library and assembling them in a logical order. The preset skill library contains several reusable skill units pre-registered. Each skill unit is pre-associated with skill description text (including meta-information such as the skill's functional description, applicable scenarios, and input / output specifications) and parameter templates (including all parameter key names required by the skill and constraint information such as the type, meaning, and example values ​​of each parameter). The workflow to be populated is a workflow skeleton containing several skill nodes and their orchestration order, but whose metadata has not yet been populated. Each skill node corresponds to a skill unit in the preset skill library.

[0047] Specifically, after receiving the task plan generated by the supervisory agent, the orchestration agent first invokes the skill filtering tool to select candidate skills from a preset skill library that match the task plan. After obtaining the candidate skill set, the orchestration agent invokes the skill orchestration tool to logically arrange the candidate skills in the set according to the task plan, generating a logical invocation order for the candidate skills. Next, the skill units in the candidate skill set are arranged sequentially to construct a workflow to be populated, containing multiple skill nodes and their arrangement order. At this stage, each skill node in the workflow to be populated only contains a skill identifier and orchestration position information; its runtime-necessary parameter values, input data, and other metadata information have not yet been populated and will be completed by the population agent in subsequent steps.

[0048] In the specific implementation process, by using an orchestration model based on task planning and the generation of logical calling order for candidate skills, it is possible to ensure that the execution logic between skills conforms to business rules and timing requirements. This ensures that the automated construction of the workflow has both a high recall and hit rate, and guarantees the logical rationality and executability of the generated workflow. At this point, step S102 may include: Based on the orchestration agent, the semantic similarity between the task planning and the descriptions of each skill in the preset skill library is calculated, and candidate skills are selected from the preset skill library according to the semantic similarity. The task plan and the candidate skills are input into a preset orchestration model. The orchestration model generates a logical calling order for the candidate skills to obtain a workflow to be filled. The logical calling order is used to determine the relative position of each candidate skill in the workflow to be filled.

[0049] Specifically, semantic similarity measures the degree of matching between the semantic text of the task plan and the semantic text of each skill description in the preset skill library. When calculating semantic similarity, the orchestration agent calls the skill filtering tool to perform the following operations: The text representation of the task plan and the skill description text of each skill unit in the preset skill library are input into a pre-built embedding model. The embedding model maps each input text to the same vector space, obtaining a task plan vector and each skill description vector. Then, the cosine similarity between the task plan vector and each skill description vector is calculated, and the calculated cosine similarity value is used as the semantic similarity score between the task plan and each skill unit. The higher the semantic similarity score, the higher the degree of matching between the function of the skill unit and the task plan. After obtaining the semantic similarity score for each skill unit, the orchestration agent sorts all skill units in the preset skill library from high to low according to the similarity score and selects a preset number (e.g., Top-K) of the top-ranked skill units as candidate skills.

[0050] Understandably, the preset orchestration model is a pre-trained language understanding model, which has the ability to understand the business process logic described by the task plan and to reasonably sort the candidate skills according to the logic. When generating the logical call order, the orchestration agent inputs the task plan and the set of candidate skills selected in (1) into the preset orchestration model. The preset orchestration model comprehensively understands the business objectives indicated by the task plan, the execution order constraints of each sub-task, and the functional characteristics of each candidate skill. It identifies the role positioning and interdependence of each candidate skill in the complete business process, and determines the sequential execution relationship of each candidate skill accordingly, and outputs the logical call order of the candidate skills. This logical call order is used to determine the relative position of each candidate skill in the workflow to be filled, that is, to clarify the predecessor and successor skills of each candidate skill in the execution sequence, and to ensure that the execution logic of the workflow to be filled conforms to the business rules and timing requirements.

[0051] In one example, the orchestration agent operates according to user instructions ( The system identifies suitable skills and orchestrates the workflow according to the logical order of instructions. The orchestration agent plans both a skill selection tool and a skill orchestration tool. The skill selection tool, based on the SentenceBERT embedding model, calculates the cosine similarity between user instructions and skill descriptions.

[0052] in, For the first The semantic similarity score between each skill and the user's instructions. This is the function for calculating cosine similarity. The embedding vector of natural language commands input by the user can be encoded into a high-dimensional semantic vector by the SentenceBERT model (such as "help me check the deposit scale of the Beijing branch in the past 3 months"). For the first Embedding vectors of the descriptive text of each skill. Next, the Top-K skill sets are selected by sorting the skills in descending order of similarity scores. ,as follows:

[0053] in, It is a unique identifier for the nth skill.

[0054] Then, the skill orchestration tool uses a trained high-level language understanding mini-model to generate a logical skill invocation sequence based on user commands and the selected skill set. :

[0055] in, This determines the final skill invocation order. The user's original natural language commands. A well-trained skill orchestration tool (implemented based on a lightweight language understanding small model).

[0056] Step S103: Extract parameter values ​​from the natural language instructions through the filling agent, and fill metadata in the skill nodes of the workflow to be filled with the parameter values ​​to generate the target workflow.

[0057] In this embodiment, the filling agent is an agent module in the multi-agent framework responsible for completing the metadata information required for runtime for each skill node in the workflow to be filled.

[0058] Understandably, after receiving the workflow to be filled generated by the orchestration agent, the filling agent first calls the template lookup tool to retrieve the parameter description and blank parameter template corresponding to each skill node in the workflow from the preset skill library. The parameter description contains information such as the meaning, data type, and example value of each parameter in the skill node, while the blank parameter template contains the parameter key names of all the parameters required for the skill node, but the values ​​of each parameter are in an unfilled state. Then, the metadata filling tool is called to extract the parameter values ​​corresponding to each parameter key name from the natural language instructions and context instructions based on the parameter descriptions of each skill node retrieved by the template lookup tool, and fill the extracted parameter values ​​into the corresponding parameter positions in the blank parameter templates, thus filling the complete metadata for each skill node.

[0059] Specifically, when the population agent populates accurate metadata for each component and generates a complete workflow, this can be done using a template lookup tool and a metadata population tool. The template lookup tool retrieves the skill invocation order. Parameter descriptions for each skill and blank parameter template The parameter descriptions include meaning, type, and example values; the parameter templates contain all the parameter keys for the skill; the metadata population tool combines user instructions and parameter description templates through a model. To ensure the accuracy of the extracted relevant information, finally, in the parameter blank template... Quickly populate metadata. Among them, This is a parameter description template for skill m. This is a blank template for the parameters of skill m.

[0060] In one example, reference Figure 4 , Figure 4 This is a framework diagram of the multi-agent system in this application. The overall architecture uses the user as the input source, and the user interacts with the system through natural language input and multi-turn dialogue commands.

[0061] As the core coordination node in the multi-agent framework, the supervisory agent receives the user's natural language input and multi-turn dialogue instructions, and then performs task allocation operations. Specifically, this includes understanding the user's intent, breaking down complex tasks and generating an overall task plan, and then issuing the task plan to the orchestration agent and the filling agent respectively.

[0062] After receiving the overall task plan from the supervisor agent, the orchestration agent starts the skill screening tool, calculates the semantic similarity between the task plan and the descriptions of each skill in the preset skill library, and selects candidate skills based on the similarity. Then, it starts the skill orchestration tool to generate the logical calling order of each candidate skill, and outputs the task plan (i.e. the workflow to be filled) to the filling agent accordingly.

[0063] After receiving the overall task plan from the supervisory agent and the task plan output by the orchestration agent, the filling agent starts the template lookup tool to retrieve the parameter descriptions and blank parameter templates of each skill node in the workflow to be filled. Then, it starts the metadata filling tool to extract parameter values ​​from natural language instructions and multi-turn dialogue instructions and fill them into the blank parameter templates, generating the complete metadata configuration of each skill node and outputting the filled workflow.

[0064] After the filling agent generates a complete workflow, it returns the workflow to the supervisory agent. The supervisory agent performs a result check and feedback on the workflow, verifying its completeness, correctness, and the rationality of the orchestration logic of each skill node. The verification results are then fed back to the user. The supervisory agent also supports iterative adjustments to the workflow based on the user's multi-turn dialogue instructions. While the orchestration agent and the filling agent are completing their respective orchestration and filling task planning, the supervisory agent continuously receives feedback from the orchestration agent and the filling agent, dynamically evaluates the rationality of the task planning, and reissues the updated overall task plan to the orchestration agent and the filling agent when adjustments are needed. Finally, the supervisory agent outputs the target workflow that meets the user's intent and has complete metadata.

[0065] In this embodiment, the workflow is constructed through the collaboration of three intelligent agents with different functions. This multi-agent collaborative architecture avoids the performance bottleneck and accuracy decline caused by a single intelligent agent having to frequently switch between multiple sub-tasks when handling complex tasks. Each intelligent agent focuses on its own scope of responsibility, which can significantly improve the accuracy and processing efficiency of automatically constructing complex processes. At the same time, each intelligent agent can be independently optimized and iterated, which enhances the maintainability and scalability of the system.

[0066] Reference Figure 5 , Figure 5 This is a flowchart illustrating the third embodiment of the interactive task processing method of this application. Based on the first embodiment described above, a third embodiment of the interactive task processing method of this application is proposed.

[0067] In the third embodiment, step S20 includes: Step S201: Based on the dependency relationship between each skill node in the target workflow, determine the earliest start time and the latest start time of each skill node, and determine the skill node whose earliest start time is equal to the latest start time as the critical skill node.

[0068] In this embodiment, the dependency relationship between skill nodes is determined by the arrangement order of skill nodes in the target workflow, and this dependency relationship is represented by a DAG (Directed Acyclic Graph).

[0069] Specifically, each skill node in the target workflow is treated as a vertex in a directed acyclic graph (DAG), and the execution time dependencies between skill nodes are treated as directed edges. If the execution result of the first skill node serves as the input or trigger condition for the second skill node, a directed edge is constructed from the first skill node to the second skill node, representing that the second skill node depends on the first skill node. After constructing the DAG, critical path analysis is performed based on it to determine the earliest start time and latest start time of each skill node. The specific calculations are fairly standard, and this embodiment does not impose any limitations on them. For example, CPM (Critical Path Method) can be used to calculate the earliest start time (EST) and latest start time (LST) of each task. ,but This is a critical task.

[0070] Step S202: Determine the key skill path based on the key skill nodes.

[0071] Step S203: Adjust the arrangement order of each skill node based on the key skill path to obtain an optimized arrangement order.

[0072] It is understandable that a critical skill path is a path formed by sequentially connecting all critical skill nodes according to their interdependencies.

[0073] In this embodiment, based on the critical skill path, a reverse breadth-first search strategy and a greedy optimization strategy can be adopted to redistribute the execution level of each skill node in the target workflow, and to schedule the critical skill nodes on the critical skill path as early as possible to shorten the maximum completion time (makespan) of the entire workflow and obtain the optimized orchestration order.

[0074] It should be understood that the execution level refers to the level identifier assigned to each skill node to represent the execution batch in the parallel execution system. Skill nodes at the same execution level have no dependency relationship and are qualified to be scheduled in parallel. Skill nodes at different execution levels are executed in ascending order of level number, with the execution level with the smaller level number being executed first.

[0075] In practical implementation, based on the core idea of ​​CPM, a greedy strategy can be used to pre-schedule the execution level of key skill nodes, enabling key skill nodes that are originally in a waiting state to execute as early as possible. This effectively shortens the maximum completion time of the entire workflow, reduces time waste and resource idleness caused by sequential waiting of skill nodes, and significantly improves the execution efficiency of the workflow and the resource utilization of the system. At this point, step S203 may include: Based on the aforementioned key skill paths, determine the time difference between each key skill node at the current level and the previous level; When the time difference is greater than a preset time threshold, the key skill node is moved up to the next higher level; The optimized arrangement order is determined based on the adjusted key skill nodes.

[0076] It should be noted that the current level is the execution level of the key skill node before this round of level adjustment operations, and the next level is the execution level immediately preceding the current level. The time difference is the total amount of time that all subsequent skill nodes of the key skill node can start executing earlier after the key skill node is moved from the current level to the next level.

[0077] In this embodiment, the preset time threshold is a pre-set time base value used to determine whether to trigger a level shift operation, for example, 0. When the calculated time difference is greater than the preset time threshold, it is determined that the key skill node meets the conditions for triggering a level shift, and the execution level of the key skill node is adjusted from the current level to the next higher level, that is, the level number of the key skill node is decremented by 1. After the shift operation is completed, the key skill node will be executed at an earlier execution level, and the start time of all its subsequent skill nodes will be advanced accordingly.

[0078] Understandably, after completing the hierarchical shift of all critical skill nodes on the critical skill path, the adjusted execution levels of each critical skill node are integrated with the current execution levels of other non-critical skill nodes. All skill nodes are then rearranged in ascending order of their execution level numbers, with skill nodes belonging to the same execution level grouped into the same execution batch. Each execution batch is executed sequentially according to its level number, forming the optimized arrangement order.

[0079] In one example, task hierarchy can be reallocated based on the critical path. First, the critical task path is traversed using a reverse breadth-first search, starting from the exit task and proceeding backward to find each critical task. For each critical task, a time window sliding strategy is used to calculate the time difference between its current level and the previous level. .like If this occurs, it triggers a layer shift, attempting to move the element to the earliest possible layer.

[0080]

[0081] in, This refers to the execution time of key skill nodes at the current level. This refers to the execution time of key skill nodes at the previous level. If A positive result indicates that moving the key skill node up one level can bring positive time benefits to the execution of the entire workflow; if ΔT is zero or negative, it means that the move operation does not produce time benefits or has a negative effect.

[0082] After adjustment, cross-level dependency checks are required to ensure that the adjusted task dependencies are still satisfied (no circular dependencies). For example, predecessor and successor checks (when moving a task, verify whether its predecessor task is already in the execution queue of the new level and ensure that the start time of the successor task is not less than the completion time of the current task) and loop detection (use the Tarjan algorithm to detect whether there are loops in the adjusted DAG, and roll back the adjustment operation if a loop is found).

[0083] In one example, reference Figure 6 , Figure 6 This is a flowchart of the heuristic dynamic hierarchical adjustment algorithm proposed in this application. Traditional chained workflow models waste significant time waiting for skill execution results and user interaction feedback during scheduling, leading to wasted computing resources and a poor user experience. Considering the bidirectional "IO-intensive" characteristics of skill invocation and user interaction in LUI implementation scenarios, we propose a heuristic dynamic hierarchical adjustment algorithm to achieve proactive perception and pre-execution of parallel executable nodes. This allows for the rational allocation of computing resources, shortening the maximum completion time of process scheduling and improving system throughput.

[0084] First, the critical path in the target workflow is identified. Based on the dependencies between skill nodes, the earliest and latest start times are calculated. Skill nodes with the same earliest and latest start times are identified as critical skill nodes, and the path formed sequentially by these critical skill nodes is identified as the critical skill path. Then, a reverse breadth-first search is used. Breadth-First Search (BFS) starts from the terminal node (i.e., the end skill node) on the critical path and traverses the critical skill nodes in the reverse direction of the directed edges, layer by layer upwards. During the traversal, it checks whether the currently traversed node is the root node (i.e., the starting skill node). If the current node is the root node, it is determined that all critical skill nodes on the critical path have been traversed. If the current node is not the root node, a greedy optimization strategy is executed. Following the reverse order from the end node to the start node, the time difference ΔT between the current level and the previous level is calculated for each critical skill node. If ΔT is greater than zero, the execution level of the critical skill node is moved up to the previous level, and the dependency check is checked. If it passes, the reverse traversal and greedy level adjustment process continue until all critical skill nodes on the critical path have been processed, completing a complete round of dynamic level adjustment iteration. After the dynamic level adjustment sub-process is completed, the resource-aware scheduling sub-process begins to determine the task time order within the level and calculate the EFT (Earliest Finish) of all processors. (Time, earliest completion time), select the processor with the smallest EFT, and then end the process.

[0085] Step S204: According to the optimized arrangement order, the target workflow is divided into multiple sub-processes, and the sub-processes are dynamically planned locally according to the user's intention to obtain the target execution plan.

[0086] In this embodiment, a sub-process is a series of process segments formed by dividing the target workflow according to a preset partitioning strategy. Each sub-process contains at least one skill node, and the sub-processes are relatively independent and cohesive in terms of business functions. User intent refers to the instructions input by the user through natural language interaction before or during the execution of the target workflow, expressing expectations or needs for adjusting the workflow execution logic. Examples include adjusting the execution parameters of a step, skipping a step, inserting a new step, or modifying the execution order of steps. The target execution plan includes the final execution order of each skill node, the connection relationships between sub-processes, the execution logic of skill nodes within each sub-process, and a dynamic scheduling scheme for how each sub-process responds to different user intents during runtime.

[0087] In the specific implementation process, a hierarchical retrieval mechanism can be used to dynamically navigate at different granularity levels (sub-process level and skill level). Matching sub-process tags are retrieved first at higher levels, and then refined at the skill level to ensure a high degree of match between the retrieved results and the user's intent. This satisfies the user's need for flexibility in interaction adjustments while limiting the impact of dynamic adjustments to local sub-processes, ensuring the stable execution of the rest of the workflow. At this point, step S204 may include: Obtain user intent from user feedback and determine the similarity score corresponding to the user intent; Based on the similarity score, a hierarchical search is performed from top to bottom in the retrieval enhancement generation hierarchy architecture to obtain a set of target tags that match the user intent; Based on the target label set, the intelligent agent is invoked to perform local dynamic planning within the sub-processes corresponding to the sub-process hierarchical labels, thereby generating the target execution plan.

[0088] In this embodiment, user intent refers to the instruction information input by the user through natural language interaction before or during the execution of the target workflow, expressing expectations or needs for adjusting the workflow execution logic. The similarity score is used to measure the degree of semantic matching between the user intent and the sub-process tags and skill tags in the target workflow.

[0089] Specifically, after obtaining the user's intention command input via natural language, the text representation of the user intention command is input into a pre-built intention encoding model. The intention encoding model maps the text of the user intention command to a vector space, generating a user intention vector. Then, the cosine similarity between the user intention vector and the label vectors of each sub-process is calculated to obtain a first similarity score between the user intention and each sub-process; the cosine similarity between the user intention vector and the label vectors of each skill is calculated to obtain a second similarity score between the user intention and each skill node. The first similarity score is used to retrieve target sub-processes that match the user intention at the sub-process level, and the second similarity score is used to retrieve target skill nodes that match the user intention at the skill level.

[0090] In this embodiment, the enhanced retrieval generation hierarchy architecture is a pre-built two-layer tag retrieval structure comprising a sub-process hierarchy and a skill hierarchy, wherein the sub-process hierarchy is the first retrieval hierarchy and the skill hierarchy is the second retrieval hierarchy. Top-down hierarchical retrieval refers to first performing coarse-grained retrieval at the sub-process hierarchy to locate the target sub-process, and then performing fine-grained retrieval within the located target sub-process to locate the target skill node, thereby narrowing the retrieval scope and improving retrieval accuracy.

[0091] Specifically, the process begins with a first search at the sub-process level. The calculated first similarity scores are sorted from highest to lowest, and a predetermined number of sub-process tags at the top of the sorted list are selected as a candidate sub-process tag set. Next, a second search is performed at the skill level. Within the skill nodes of each sub-process in the candidate sub-process tag set, the calculated second similarity scores are sorted from highest to lowest, and a predetermined number of skill tags at the top of the sorted list are selected as a candidate skill tag set. The sub-process tags in the candidate sub-process tag set and the skill tags in the candidate skill tag set are combined to form the target tag set matching the user's intent. If the highest first similarity score retrieved at the sub-process level is lower than a predetermined threshold, it indicates that the user's intent does not point to any of the defined sub-processes. In this case, the user intent is determined to be a global intent, the hierarchical search process is terminated, and a global workflow adjustment process is triggered.

[0092] In this embodiment, local dynamic programming only adjusts the orchestration within a specific sub-process of the target workflow, without affecting the established orchestration structure of other sub-processes. The target execution plan includes the final execution order of each skill node, the connection relationship between each sub-process, and the execution logic of the skill nodes within each sub-process.

[0093] Specifically, based on the candidate sub-process tags in the target tag set, the corresponding sub-process is located as the target sub-process. Then, candidate skill tags belonging to the target sub-process are extracted from the target tag set as the basis for adjusting the local dynamic planning. The user intent, the current internal orchestration structure of the target sub-process, and the candidate skill tags are input into the supervisory agent, which re-parses the user intent's adjustment requirements for the target sub-process and generates a new local task plan. Based on the new local task plan, the orchestration agent reselects candidate skills from the preset skill library within the skill nodes included in the target sub-process and rearranges them according to the logical order of the new task plan, generating an updated local workflow to be filled. The filling agent re-extracts parameter values ​​and fills metadata for the skill nodes in the updated local workflow to be filled, generating an updated target sub-process. After generating the updated target sub-process, the updated target sub-process is recombined with other unadjusted sub-processes according to the original sub-process connection relationships to obtain a complete target execution plan.

[0094] Optionally, after completing the local dynamic programming of the target sub-process, the internal orchestration structure of the updated target sub-process is also checked for dependencies. This involves checking whether there are circular dependencies between the updated skill nodes, whether data dependencies are satisfied, and whether all required parameters are correctly filled. If the check passes, the updated target sub-process is combined with other sub-processes to generate a target execution plan. If the check fails, a clarification inquiry is sent to the user through the supervision agent or the local dynamic programming result is automatically corrected.

[0095] In one example, reference Figure 7 , Figure 7 This is a flowchart of the runtime self-limiting dynamic programming of this application. First, it shows that the target workflow is pre-divided into three sub-processes: SUB-F A, SUB-F B, and SUB-F C. SUB-F B, as a potential target sub-process for subsequent dynamic programming, is highlighted. The process then enters the "RAG hierarchical dynamic recall" stage. This stage performs a coarse-grained search from top to bottom at the sub-process level through "high-level retrieval," recalling SUB-F layer tags that match the user's intent, specifically pointing to SUB-F B in the diagram. After recalling the SUB-F layer tags, and confirming through "conditional judgment" that the user's intent indeed points to this sub-process, the process enters the "low-level retrieval" stage, narrowing the search scope to SUB-F. Within sub-sub ...

[0096] In this embodiment, global critical path analysis is combined with local dynamic adjustments, giving the system the ability to respond to real-time changes in user intent while ensuring optimal overall workflow execution efficiency. This allows the system to flexibly adapt to user interaction adjustment needs without affecting overall stability, balancing workflow execution stability and interaction flexibility.

[0097] Reference Figure 8 , Figure 8This is a flowchart illustrating the fourth embodiment of the interactive task processing method of this application. Based on the first embodiment described above, the fourth embodiment of the interactive task processing method of this application is proposed.

[0098] In the fourth embodiment, step S30 includes: Step S301: Identify the communication protocol corresponding to the skill node through the protocol adaptation layer of the preset execution agent, and convert the communication protocol into the target protocol format.

[0099] In this embodiment, a preset execution agent is used to achieve unified scheduling and execution of skills across multiple business sectors. It comprises a three-layer architecture: a protocol adaptation layer, a permission verification layer, and a skill execution layer. The protocol adaptation layer is the module within the preset execution agent responsible for identifying the communication protocol types supported by the skill nodes and converting execution requests into the target protocol format. The target protocol format is the communication protocol format actually supported by the target heterogeneous service corresponding to the skill node.

[0100] Specifically, when scheduling to a specific skill node according to the target execution plan, the protocol configuration information of that skill node is first obtained. This protocol configuration information is pre-registered in a preset skill library and stored in association with the skill node, and includes at least the native communication protocol types supported by the skill node and the server endpoint address of the target heterogeneous service corresponding to the skill node. The protocol adaptation layer identifies the communication protocol type corresponding to the skill node based on the obtained protocol configuration information. Communication protocol types include HTTP synchronous request protocol, SSE (Server-Sent Events) streaming protocol, and WebSocket full-duplex communication protocol.

[0101] Understandably, after identifying the communication protocol corresponding to a skill node, the protocol adaptation layer converts the execution request of that skill node from the current protocol format to the target protocol format required by its corresponding heterogeneous service. The protocol adaptation layer uses the abstract factory pattern to achieve dynamic identification and conversion of multiple protocol types.

[0102] Optionally, for skill nodes with an HTTP communication protocol, the protocol adaptation layer encapsulates the execution request into an HTTP request message and determines the request method (including GET, POST, PUT, DELETE, etc.) based on the skill node's configuration information. If the target heterogeneous service adopts a synchronous request mode, the protocol adaptation layer sends an HTTP request in a synchronous request mode and waits for a complete response. If the target heterogeneous service adopts an asynchronous long polling mode, the protocol adaptation layer sends an HTTP request in an asynchronous long polling mode and decides whether to continue maintaining the connection and waiting for subsequent results based on the response status after receiving the response.

[0103] Optionally, for skill nodes with an SSE communication protocol, the protocol adaptation layer encapsulates the execution request into an SSE request, establishes an SSE connection with the target heterogeneous service, and combines chunked encoding to achieve low-latency transmission of the large language model's streaming output. After the SSE connection is established, the protocol adaptation layer continuously receives data blocks pushed by the target heterogeneous service in the form of an event stream. Each time a data block is received, it is passed to the upper layer as part of the streaming response until the stream end marker is received.

[0104] Optionally, for skill nodes using the WebSocket communication protocol, the protocol adaptation layer encapsulates the execution request into a WebSocket handshake request and establishes a bidirectional communication connection with the target heterogeneous service by executing the WebSocket handshake protocol. After the connection is established, the protocol adaptation layer uses a connection pool to manage the WebSocket connection, avoiding the resource overhead caused by frequently creating and destroying connections, and configures a heartbeat detection mechanism to periodically send heartbeat messages to maintain the connection's active state, preventing the connection from being disconnected by intermediate network devices due to prolonged idle time. The protocol adaptation layer supports bidirectional transmission of binary and text data through the established WebSocket connection, sending the execution request to the target heterogeneous service, and parsing the received response data according to the WebSocket protocol's data frame format to extract the skill node's execution result data.

[0105] After completing the protocol conversion, the protocol adaptation layer outputs the execution request in the converted target protocol format to the next processing layer (i.e., the permission verification layer) of the preset execution agent, and the permission verification layer performs permission-related processing on the execution request.

[0106] Step S302: Through the permission verification layer of the preset execution agent, the unified identity authentication token is exchanged for an access token for the heterogeneous service corresponding to the skill node.

[0107] In this embodiment, the permission verification layer is a processing module within the preset execution proxy responsible for authenticating permissions and converting tokens for the execution requests of skill nodes. The unified identity authentication token is a global identity credential held by the user initiating the target workflow execution request within the unified identity authentication system, such as a unified ID token. This token is issued by an enterprise-level unified identity authentication system and is used to identify the user across multiple business systems. The heterogeneous service access token is a local access credential required by the independent permission systems of the target heterogeneous services (e.g., API services, large model services, microservices, etc.) called by the skill node. It is used to verify the caller's identity and operational permissions when calling the heterogeneous service. When the permission verification layer converts the unified identity authentication token into a heterogeneous service access token, it achieves cross-system permission transfer and identity mapping without requiring users to repeatedly log in and authenticate across different systems.

[0108] Specifically, after the protocol adaptation layer completes the protocol conversion, it passes the execution request containing the unified identity authentication token to the permission verification layer. The permission verification layer parses the unified identity authentication token in the execution request and extracts the user identification information (such as user ID, department information, role information, etc.) contained within it. Then, the permission verification layer obtains the service identifier information of the skill node to be executed. This service identifier information includes at least the service name of the target heterogeneous service corresponding to the skill node and the information of the service system to which it belongs. After obtaining the user identification information and the service identifier information of the skill node from the unified identity authentication token, the permission verification layer calls the token conversion gateway to perform a token exchange operation. After receiving the access token returned by the token conversion gateway, the permission verification layer injects the access token into the corresponding authentication field in the request header or request parameters of the execution request, so that the execution request carries the access credentials required by the target heterogeneous service.

[0109] Step S303: Through the skill execution layer of the preset execution agent, the heterogeneous service is invoked based on the target protocol format and the access token to obtain the execution result of the target workflow.

[0110] In this embodiment, the skill execution layer is the execution module within the preset execution proxy responsible for ultimately invoking the target heterogeneous service corresponding to the skill node and obtaining the execution result. The skill execution layer receives an execution request from the permission verification layer, which includes a request message in the target protocol format converted by the protocol adaptation layer and an access token injected by the permission verification layer. Based on this execution request, the skill execution layer invokes the heterogeneous service corresponding to the skill node, obtains the service execution result, and returns the result in a preset format as the output of the skill node in the target workflow.

[0111] Specifically, after receiving an execution request, the skill execution layer first parses the service identifier information in the execution request to determine the type of the target heterogeneous service corresponding to the current skill node. The types of heterogeneous services include API services, large language model services, plugin services, function services, and mock services, etc. Based on the different types of the target heterogeneous service, the skill execution layer uses the corresponding invocation strategy to execute the skill node.

[0112] In one example, reference Figure 9 , Figure 9 This is a flowchart illustrating the execution process of the skill execution agent in this application. The scheduling engine, based on the execution order and triggering conditions of each skill node determined by the target execution plan, identifies the currently executing skill node and initiates an input parameter collection interaction request to the card platform. The card platform guides the user through a visual card form to collect and confirm the required input parameters for the skill node. After the user completes the input parameter filling and confirmation on the card platform, the platform returns the confirmed input parameter data to the scheduling engine. The scheduling engine then transmits the skill node's execution request along with the input parameter data to the skill execution agent. Internally, the skill execution agent first uses a protocol adapter to identify the communication protocol type corresponding to the skill node and converts the execution request into the target protocol format required by the target heterogeneous service. Then, the permission verifier verifies the user who initiated the request. The unified identity authentication token is exchanged for an access token for the target heterogeneous service corresponding to the skill node. Finally, the skill executor calls the target heterogeneous service to execute the skill node and obtain the execution result based on the converted target protocol format and the exchanged access token. After obtaining the execution result, the skill execution agent returns the execution result to the scheduling engine and the card platform respectively. After receiving the execution result, the scheduling engine continues to trigger the scheduling and execution of the next skill node. After receiving the execution result, the card platform displays the execution result of the current skill node to the user in a visual way. At the same time, the user can perform subsequent interactive operations based on the execution result displayed by the card platform (such as confirming the result to continue execution, modifying parameters to re-execute, or terminating the current workflow).

[0113] In this embodiment, a layered decoupling and dynamic adaptation design is adopted. The three-layer architecture enables the execution agent to have good scalability and generalization capabilities, and can quickly adapt to new protocol types, permission systems and business services, significantly reducing the system's integration cost and deployment cycle in multi-business scenarios.

[0114] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the interactive task processing method of this application. Any simple modifications based on this technical concept are within the protection scope of this application.

[0115] This application also provides an interactive task processing device, please refer to... Figure 10 The interactive task processing device includes: The construction module 10 is used to respond to natural language commands input by the user and call the intelligent agent to construct the corresponding target workflow, wherein the target workflow includes multiple skill nodes arranged in an orchestration order; The scheduling module 20 is used to adjust the arrangement order of the skill nodes and divide the adjusted target workflow into multiple sub-processes to obtain the target execution plan; The execution module 30 is used to call a preset execution agent to execute the skill node according to the target execution plan, so as to obtain the execution result of the target workflow.

[0116] The interactive task processing device provided in this application, employing the interactive task processing method in the above embodiments, can solve the technical problem that it is difficult to meet the requirements of automation and execution efficiency in business scenarios when responding to users' natural language commands to achieve automated task processing. Compared with the prior art, the beneficial effects of the interactive task processing device provided in this application are the same as those of the interactive task processing method provided in the above embodiments, and other technical features in the interactive task processing device are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0117] This application provides an interactive task processing device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the interactive task processing method in Embodiment 1 above.

[0118] The following is for reference. Figure 11 This document illustrates a structural schematic diagram of an interactive task processing device suitable for implementing embodiments of this application. The interactive task processing device in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Description), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 11 The interactive task processing device shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0119] like Figure 11As shown, the interactive task processing device may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.) that can perform various appropriate actions and processes according to a program stored in a read-only memory 1002 or a program loaded from a storage device 1003 into a random access memory 1004. The random access memory 1004 also stores various programs and data required for the operation of the interactive task processing device. The processing unit 1001, the read-only memory 1002, and the random access memory 1004 are interconnected via a bus 1005. An input / output interface 1006 is also connected to the bus. Typically, the following systems can be connected to the input / output interface 1006: input devices 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 allows the interactive task processing device to communicate wirelessly or wiredly with other devices to exchange data. Although the figures show interactive task processing devices with various systems, it should be understood that it is not required to implement or possess all of the systems shown. More or fewer systems may be implemented alternatively.

[0120] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from read-only memory 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0121] The interactive task processing device provided in this application, employing the interactive task processing method in the above embodiments, can solve the technical problem that it is difficult to meet the requirements of business scenarios for automation level and execution efficiency in responding to users' natural language commands to achieve automated task processing. Compared with the prior art, the beneficial effects of the interactive task processing device provided in this application are the same as those of the interactive task processing method provided in the above embodiments, and other technical features in this interactive task processing device are the same as those disclosed in the previous embodiment method, and will not be repeated here.

[0122] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0123] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0124] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, the computer-readable program instructions being used to execute the interactive task processing method in the above embodiments.

[0125] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0126] The aforementioned computer-readable storage medium may be included in an interactive task processing device; or it may exist independently and not assembled into an interactive task processing device.

[0127] The aforementioned computer-readable storage medium carries one or more programs, which, when executed by an interactive task processing device, cause the interactive task processing device to perform the interactive task processing method described above.

[0128] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0129] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0130] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0131] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described interactive task processing method. This solves the technical problem that current methods struggle to meet the demands for automation and execution efficiency in responding to users' natural language commands to automate task processing. Compared to existing technologies, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the interactive task processing method provided in the above embodiments, and will not be elaborated upon here.

[0132] The above description is only a part of the embodiments of this application and does not limit the scope of this application. All equivalent structural transformations made under the technical concept of this application and using the content of this application specification and drawings, or direct / indirect applications in other related technical fields, are included within the protection scope of this application.

[0133] It should be noted that the data collection, tag management, rule setting, and push decision-making processes involved in this application are designed to work with other technical features to solve technical problems. They do not involve or support any illegal activities. Any data processing that may violate laws and regulations (such as unauthorized collection of privacy data, generation of discriminatory tags, setting unfair rules, or pushing illegal information) is not within the scope of protection of this application's technical solution. Of course, the user data in this application will be encrypted, anonymized, or de-identified before storage to ensure user data security.

Claims

1. An interactive task processing method, characterized in that, The interactive task processing method includes: In response to a natural language command input by the user, an intelligent agent is invoked to construct a corresponding target workflow, wherein the target workflow includes multiple skill nodes arranged in an orchestrated order; The arrangement order of the skill nodes is adjusted, and the adjusted target workflow is divided into multiple sub-processes to obtain the target execution plan; According to the target execution plan, the preset execution agent is invoked to execute the skill node, and the execution result of the target workflow is obtained.

2. The interactive task processing method as described in claim 1, characterized in that, The intelligent agent includes a supervisory agent, an orchestration agent, and a filling agent; The process of invoking the intelligent agent to construct the corresponding target workflow includes: Based on contextual instructions, the supervisory agent parses the natural language instructions to generate a task plan; Based on the task planning, candidate skills are selected from the preset skill library through the orchestration agent, and the candidate skills are arranged in the logical order of the task planning to generate a workflow to be filled. The filling agent extracts parameter values ​​from the natural language instructions and uses these parameter values ​​to fill metadata in the skill nodes of the workflow to be filled, thereby generating the target workflow.

3. The interactive task processing method as described in claim 2, characterized in that, The step of selecting candidate skills from a preset skill library based on the task planning, and arranging the candidate skills according to the logical order of the task planning to generate a workflow to be populated includes: Based on the orchestration agent, the semantic similarity between the task planning and the descriptions of each skill in the preset skill library is calculated, and candidate skills are selected from the preset skill library according to the semantic similarity. The task plan and the candidate skills are input into a preset orchestration model. The orchestration model generates a logical calling order for the candidate skills to obtain a workflow to be filled. The logical calling order is used to determine the relative position of each candidate skill in the workflow to be filled.

4. The interactive task processing method as described in claim 1, characterized in that, The process of adjusting the arrangement order of the skill nodes and dividing the adjusted target workflow into multiple sub-processes to obtain the target execution plan includes: Based on the dependencies between skill nodes in the target workflow, the earliest start time and the latest start time of each skill node are determined, and the skill node whose earliest start time is equal to the latest start time is determined as the critical skill node. Determine key skill paths based on the key skill nodes; The arrangement order of each skill node is adjusted based on the key skill path to obtain an optimized arrangement order; Based on the optimized arrangement order, the target workflow is divided into multiple sub-processes, and the sub-processes are dynamically planned locally according to the user's intent to obtain the target execution plan.

5. The interactive task processing method as described in claim 4, characterized in that, The process of adjusting the arrangement order of each skill node based on the key skill path to obtain an optimized arrangement order includes: Based on the aforementioned key skill paths, determine the time difference between each key skill node at the current level and the previous level; When the time difference is greater than a preset time threshold, the key skill node is moved up to the next higher level; The optimized arrangement order is determined based on the adjusted key skill nodes.

6. The interactive task processing method as described in claim 4, characterized in that, The step of performing local dynamic planning on the sub-processes based on user intent to obtain the target execution plan includes: Obtain user intent from user feedback and determine the similarity score corresponding to the user intent; Based on the similarity score, a hierarchical search is performed from top to bottom in the retrieval enhancement generation hierarchy architecture to obtain a set of target tags that match the user intent; Based on the target label set, the intelligent agent is invoked to perform local dynamic planning within the sub-processes corresponding to the sub-process hierarchical labels, thereby generating the target execution plan.

7. The interactive task processing method as described in claim 1, characterized in that, The step of invoking a preset execution agent to execute the skill node according to the target execution plan, and obtaining the execution result of the target workflow, includes: The communication protocol corresponding to the skill node is identified through the protocol adaptation layer of the preset execution agent, and the communication protocol is converted into the target protocol format. The unified identity authentication token is exchanged for an access token for the heterogeneous service corresponding to the skill node through the permission verification layer of the preset execution agent. The execution result of the target workflow is obtained by invoking the heterogeneous service through the skill execution layer of the preset execution agent based on the target protocol format and the access token.

8. An interactive task processing device, characterized in that, The device includes: A construction module is used to respond to natural language commands input by the user and call the intelligent agent to construct the corresponding target workflow, wherein the target workflow includes multiple skill nodes arranged in an orchestration order; The scheduling module is used to adjust the arrangement order of the skill nodes and divide the adjusted target workflow into multiple sub-processes to obtain the target execution plan; The execution module is used to call a preset execution agent to execute the skill node according to the target execution plan, so as to obtain the execution result of the target workflow.

9. An interactive task processing device, characterized in that, The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the interactive task processing method as described in any one of claims 1 to 7.

10. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the interactive task processing method as described in any one of claims 1 to 7.

Images