Task scheduling method and device, computer device, readable storage medium and program product

Abstract

This application relates to a task orchestration method, apparatus, computer device, computer-readable storage medium, and computer program product. The method includes: obtaining the nodes to be executed in the current running process of a task execution graph; executable nodes are task nodes whose parent nodes have all successfully executed; assigning the nodes to be executed to corresponding target agents according to their task attributes; the target agents executing the nodes to be executed and outputting the corresponding execution results; performing a correctness check on the execution results, and determining that the node to be executed has successfully executed when the execution result passes the correctness check; updating the task execution graph based on the nodes to be executed, and continuing to execute the steps of obtaining the nodes to be executed in the current running process of the task execution graph based on the updated task execution graph, until all task nodes in the task execution graph have successfully executed. This method can improve the parallel scheduling efficiency of the task execution graph.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a task orchestration method, apparatus, computer device, computer-readable storage medium, and computer program product. Background Technology

[0002] With the development of artificial intelligence and large language model technologies, multi-agent collaborative development technologies based on large language models have gradually emerged. This technology uses different agents to perform tasks such as planning, coding, testing, and review, and combines directed acyclic graphs (DAGs) to achieve task scheduling and parallel execution, thereby improving the automation level of complex software development tasks.

[0003] In related technologies, the scheduling system usually executes the corresponding tasks according to the dependencies between task nodes. When a task node fails to execute, it is usually retried in place to re-execute the failed task. After the failed task is successfully executed, its subsequent dependent tasks are then executed.

[0004] In the above method, when multiple executable task nodes exist in the same running process, if any one of the task nodes fails, it is usually necessary to repeat the execution of the failed task node in place until it succeeds, before continuing the processing of subsequent tasks in the current running process. Therefore, the failure of a single task node can easily affect the execution progress of other executable task nodes in the same running process, reducing the parallel scheduling efficiency of the task execution graph. Summary of the Invention

[0005] Therefore, it is necessary to provide a task orchestration method, apparatus, computer device, computer-readable storage medium, and computer program product that can improve the parallel scheduling efficiency of task execution graphs in response to the above-mentioned technical problems.

[0006] Firstly, this application provides a task orchestration method, including:

[0007] Obtain the nodes to be executed in the current running process in the task execution graph; the nodes to be executed include triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for task nodes whose execution results failed the correctness check in the previous run; the executable nodes are task nodes whose parent nodes have all executed successfully;

[0008] Based on the task attributes of the node to be executed, the node to be executed is assigned to the corresponding target agent; the target agent is used to execute the node to be executed and output the corresponding execution result;

[0009] The execution result is checked for correctness, and when the execution result passes the correctness check, the node to be executed is determined to have executed successfully.

[0010] Based on the node to be executed, update the task execution graph, and continue to execute the step of obtaining the node to be executed in the current running process of the task execution graph based on the updated task execution graph, until all the task nodes in the task execution graph are executed successfully.

[0011] In one embodiment, the method further includes:

[0012] When the execution result fails the correctness check, a target repair node corresponding to the node to be executed is generated; the node to be executed is the parent node of the target repair node; the target repair node includes one or more of the error information, task output information and repair scope information corresponding to the node to be executed.

[0013] The step of updating the task execution graph based on the node to be executed includes:

[0014] Update the task execution graph based on the target repair node.

[0015] In one embodiment, generating the target repair node corresponding to the node to be executed further includes:

[0016] Obtain the number of repair attempts corresponding to the node to be executed;

[0017] When the number of repairs is less than a preset threshold, a target repair node corresponding to the node to be executed is generated.

[0018] In one embodiment, the correctness check of the execution result includes:

[0019] Based on the task attribute matching detection rules of the node to be executed;

[0020] Based on the aforementioned detection rules, the execution result is subjected to one or more of the following: structured field inspection, regular expression matching detection, and decision field detection.

[0021] In one embodiment, the step of performing one or more of the following on the execution result based on each of the detection rules: structured field inspection, regular expression matching detection, and decision field detection:

[0022] Perform structured field checks on the execution results;

[0023] Based on the passing of the structured field check, regular expression matching is performed on the execution result;

[0024] Based on the successful regular expression matching detection, the execution result is then subjected to field detection.

[0025] In one embodiment, the step of obtaining the task execution graph before the node to be executed in the current running process further includes:

[0026] Receive tasks to be executed;

[0027] When the task to be executed is a natural language task, the natural language task is converted into structured information, and the task to be executed is split into multiple task nodes based on the structured information. Based on the dependency relationship between each task node and the task attributes of each task node, the task execution graph is constructed.

[0028] When the task to be executed is the structured information, the task to be executed is split into multiple task nodes based on the structured information, and the task execution graph is constructed based on the dependency relationship between each task node and the task attributes of each task node.

[0029] In one embodiment, assigning the node to be executed to the corresponding target agent based on the task attributes of the node to be executed includes:

[0030] Based on the task attributes, candidate proxies for the node to be executed are determined;

[0031] Calculate the execution cost of each candidate agent, and select the target agent from the candidate agents based on the execution cost.

[0032] In one embodiment, after selecting the target agent from the candidate agents based on the execution cost, the method further includes:

[0033] Perform a validity check on the tool name corresponding to the target agent;

[0034] When the tool name passes the validity check, the tool permission check is performed on the target agent based on the tool whitelist corresponding to the target agent;

[0035] When the tool's permission verification passes, the target proxy is subjected to path permission verification based on the path permission rules corresponding to the target path.

[0036] In one embodiment, the node to be executed is the repair node; the process by which the target agent executes the node to be executed includes:

[0037] Based on the label of the repair node, determine the reference node corresponding to the repair node;

[0038] Obtain the first error execution information and the first historical repair information corresponding to the reference node;

[0039] Obtain second error execution information and second historical repair information corresponding to similar historical nodes; the similar historical nodes are the task nodes in the task execution graph that have the same task type as the reference node.

[0040] Based on the error execution information, the historical repair information, the second error execution information, and the second historical repair information, repair reference information is generated;

[0041] Based on the repair reference information, the repair node is executed.

[0042] Secondly, this application also provides a task orchestration apparatus, comprising:

[0043] The acquisition module is used to acquire the nodes to be executed in the current running process of the task execution graph; the nodes to be executed include triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for task nodes whose execution results failed the correctness check in the previous run; the executable nodes are task nodes whose parent nodes have all been executed successfully;

[0044] The proxy allocation module is used to allocate the node to be executed to the corresponding target proxy according to the task attributes of the node to be executed; the target proxy is used to execute the node to be executed and output the corresponding execution result;

[0045] The verification module is used to check the correctness of the execution result, and when the execution result passes the correctness check, it is determined that the node to be executed has been successfully executed;

[0046] The iteration module is used to update the task execution graph based on the node to be executed, and continue to execute the step of obtaining the node to be executed in the current running process of the task execution graph based on the updated task execution graph, until all the task nodes in the task execution graph are executed successfully.

[0047] Thirdly, this application also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method in any of the above embodiments.

[0048] Fourthly, this application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method in any of the above embodiments.

[0049] Fifthly, this application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the methods in any of the above embodiments.

[0050] The aforementioned task orchestration method, apparatus, computer equipment, computer-readable storage medium, and computer program product first acquire the executable nodes currently in operation. These executable nodes include task nodes whose parent nodes have all successfully executed, and repair nodes corresponding to task nodes whose execution results failed the correctness check in the previous run. This allows the repair nodes corresponding to task nodes whose execution results failed the correctness check to participate in task execution simultaneously with other executable nodes currently in operation, thereby reducing the blocking impact of a single task node failure on the current running process and improving the parallel scheduling efficiency of the task execution graph. Furthermore, after the target agent completes the execution of the repair nodes and executable nodes, it performs a correctness check on the corresponding execution results. If the correctness check passes, the state of the corresponding task node is updated, and a new task execution graph is formed. Subsequent task scheduling and processing continue based on the updated task execution graph, enabling the task execution graph to dynamically repair and advance tasks during task execution, thus improving the overall execution efficiency in complex task scenarios. Attached Figure Description

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

[0052] Figure 1 This is a flowchart illustrating the steps of a task orchestration method in one embodiment;

[0053] Figure 2 This is a schematic diagram of the task execution graph in one embodiment;

[0054] Figure 3 This is a schematic diagram of the task execution graph in another embodiment;

[0055] Figure 4 This is a flowchart illustrating the steps of a task orchestration method in an exemplary embodiment.

[0056] Figure 5 This is a structural block diagram of a task orchestration device in one embodiment;

[0057] Figure 6 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0058] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0059] In one embodiment, such as Figure 1 As shown, a task orchestration method is provided. This embodiment illustrates the method applied to a terminal. It is understood that this method can also be applied to a server, and further to a system including both a terminal and a server, and implemented through interaction between the terminal and the server. In this embodiment, the method includes the following steps:

[0060] Step 102: Obtain the nodes to be executed in the current running process in the task execution graph; the nodes to be executed include the triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for task nodes whose execution results did not pass the correctness check in the previous running process; the executable nodes are task nodes whose parent nodes have all been executed successfully.

[0061] Here, a task execution graph refers to a task topology graph used to represent the execution relationships between multiple task nodes. The task execution graph includes multiple task nodes, and dependencies exist between these task nodes. For example, combining... Figure 2 , Figure 2 This is a schematic diagram of the task execution graph in one embodiment. Figure 2 In this example, node A is the parent node of both node B and node C. Only after node A executes successfully will nodes B and C be in a ready state, i.e., executable nodes in this example.

[0062] Because different task nodes execute successfully in each run of the task execution graph, the number of nodes to be executed changes in each run. Therefore, before each execution, the nodes to be executed in the current run are retrieved. These nodes fall into two categories: executable nodes (as described above, without further elaboration) and repair nodes (those that have already been triggered). Repair nodes are the task nodes corresponding to those whose execution results failed the correctness check in the previous run. For example, when the execution result of a task node fails the correctness check, a repair node is generated for that task node and added to the task execution graph. Combined with... Figure 3 When the output of node B fails the correctness check, a corresponding repair node will be generated, denoted as node B-1.

[0063] During the current execution process, if a repair node is triggered, it can be designated as a node to be executed. "Triggered" means the corresponding repair node meets preset repair execution conditions. Specifically, after a repair node is generated, the status of the corresponding task node that failed the correctness check is updated to a repairable failure state, and a dependency relationship is established between that task node and the repair node. When the task execution graph re-scans nodes, if it detects that the parent node corresponding to the repair node is in a repairable failure state, the repair node is deemed to meet the execution conditions, and its status is updated to a ready state, thus triggering the repair node's execution.

[0064] For example, in combination Figure 3 When node B fails the correctness check, its state is updated to a repairable failure state, and a repair node B-1 is generated. During the next round of task execution graph scanning, since node B meets the corresponding repair trigger conditions, repair node B-1 is set to a ready state and participates in subsequent task scheduling and execution as a node to be executed in the current running process.

[0065] Step 104: Based on the task attributes of the node to be executed, assign the node to the corresponding target agent; the target agent is used to execute the node to be executed and output the corresponding execution result.

[0066] In this context, the target agent refers to the intelligent execution entity used to execute the corresponding task node. The target agent can be an Artificial Intelligence Agent (AI Agent) or other automated execution units capable of performing the corresponding task. In this embodiment, the target agent includes at least one of a Planner Agent, a Developer Agent, a Critic Agent, and a Test Agent.

[0067] Task attributes refer to the execution configuration information corresponding to each task node, including the target agent type, target model type, and correctness detection rules. When generating the task execution graph, corresponding task attributes are pre-configured for each task node based on its task content and type. For example, planning task nodes correspond to planning agents, development task nodes to development agents, and review task nodes to review agents. Different task nodes can also correspond to different target models and different correctness detection rules.

[0068] Optionally, a corresponding target agent is assigned to the node to be executed based on its task attributes. The target agent first determines the corresponding target model based on the task attributes, and then performs task processing based on the task input corresponding to the node to be executed, to obtain the corresponding execution result.

[0069] Step 106: Perform a correctness check on the execution result, and determine that the node to be executed is successful when the execution result passes the correctness check.

[0070] After obtaining the execution result, a correctness check is performed to determine whether the result meets the preset requirements of the corresponding task. When the execution result passes the correctness check, it means that the result meets the preset requirements of the corresponding task. At this point, the corresponding node to be executed is determined to have been executed successfully, and the task execution graph is updated.

[0071] Optionally, before performing correctness checks on the execution results, the corresponding detection rules for the nodes to be executed are matched, and the execution results are checked for correctness based on the detection rules. Different types of nodes to be executed correspond to different detection rules. For example, planning tasks correspond to planning detection rules, development tasks to code detection rules, testing tasks to testing detection rules, and review tasks to review detection rules.

[0072] Optionally, the process of using detection rules to check the correctness of the execution result includes one or more of the following: structured field checks, regular expression matching checks, and decision field checks.

[0073] Step 108: Based on the nodes to be executed, update the task execution graph, and continue to execute the steps of obtaining the nodes to be executed in the current running process in the task execution graph based on the updated task execution graph, until all task nodes in the task execution graph are executed successfully.

[0074] When a node to be executed is determined to have been executed successfully, the status of the corresponding node to be executed will be updated to a successful status, and the execution status of subsequent task nodes that have a dependency relationship with the node to be executed will be re-determined.

[0075] Specifically, for a task node whose parent node is the node to be executed, it is determined whether all its corresponding parent nodes are in a successful state. When all parent nodes are in a successful state, the corresponding task node is updated to a ready state, so that the corresponding task node becomes an executable node in the next running process.

[0076] After the task execution graph is updated, the currently running nodes will be retrieved based on the updated task execution graph. The task allocation, task execution, and correctness check processes will be re-executed according to the updated task execution graph, so that the task nodes in the task execution graph will be executed step by step according to their dependencies.

[0077] For example, in combination Figure 2 When node A executes successfully, its status is updated to "successful". Since nodes B and C both have node A as their parent node, the execution conditions of nodes B and C are reassessed. When the parent nodes corresponding to nodes B and C both execute successfully, nodes B and C are updated to "ready" and participate in subsequent task scheduling as nodes to be executed in the next running process.

[0078] In the above task orchestration method, firstly, the executable nodes in the current running process are obtained. These executable nodes include task nodes whose parent nodes have all successfully executed, and repair nodes corresponding to task nodes whose execution results failed the correctness check in the previous run. This allows the repair nodes corresponding to task nodes whose execution results failed the correctness check to participate in task execution simultaneously with other executable nodes in the current running process, thereby reducing the blocking impact of a single task node failure on the current running process and improving the parallel scheduling efficiency of the task execution graph. Furthermore, after the target agent completes the execution of the repair nodes and executable nodes, a correctness check is performed on the corresponding execution results. If the correctness check passes, the state of the corresponding task node is updated, forming a new task execution graph. Subsequent task scheduling and processing continue based on the updated task execution graph, enabling the task execution graph to dynamically repair and advance tasks during task execution, improving the overall execution efficiency and task processing stability in complex task scenarios.

[0079] Furthermore, in one embodiment, the above method further includes: when the execution result fails the correctness check, generating a target repair node corresponding to the node to be executed; the node to be executed is the parent node of the target repair node; the target repair node includes one or more of the error information, task output information and repair scope information corresponding to the node to be executed; updating the task execution graph based on the node to be executed, including: updating the task execution graph based on the target repair node.

[0080] If the execution result of the node to be executed fails the correctness check, a corresponding target repair node is generated. The target repair node establishes a dependency relationship with the node to be executed, and the target repair node takes the node to be executed as its parent node. Continuing with... Figure 3 When the execution result of node B fails the correctness check, a corresponding target repair node B-1 will be generated, and a dependency relationship between node B and node B-1 will be established.

[0081] When generating a target repair node, one or more of the error information, task output information, and repair scope information corresponding to the node to be executed are injected into the target repair node. Among them, the error information refers to the abnormal information, error cause, or information that does not meet the preset requirements found during the correctness detection process; the task output information refers to the execution result corresponding to the node to be executed; and the repair scope information refers to the target object, target content, or target area that the target repair node is allowed to repair.

[0082] Optionally, the target repair node is added to the task execution graph, and a dependency relationship is established between the node to be executed and the target repair node; at the same time, the status of the node to be executed is updated to a repairable failure status so that the target repair node is triggered.

[0083] In the above embodiments, target repair nodes are generated to repair failed tasks, and the target repair nodes are added to the task execution graph for subsequent scheduling, thereby avoiding the blockage of the entire task execution process due to the failure of a single task node and improving the parallel processing efficiency of the task execution graph.

[0084] Furthermore, in one embodiment, the above-mentioned generation of the target repair node corresponding to the node to be executed further includes: obtaining the number of repairs corresponding to the node to be executed; when the number of repairs is less than a preset threshold, generating the target repair node corresponding to the node to be executed.

[0085] Because some task nodes may fail to complete the corresponding repair due to complex logical errors, missing dependencies, or other abnormal reasons, the generated target repair nodes may not be able to complete the repair. Therefore, if the repair process is not restricted, target repair nodes may be continuously generated, thereby consuming system resources and affecting task execution efficiency. Therefore, in this embodiment, the number of repair attempts corresponding to the node to be executed will be obtained.

[0086] Specifically, when the number of repairs is less than the preset threshold, it means that the repair process corresponding to the current node to be executed has not yet reached the preset repair limit, and at this time, the target repair node corresponding to the node to be executed is generated; when the number of repairs is greater than or equal to the preset threshold, the generation of new target repair nodes is stopped.

[0087] In the above embodiments, by limiting the number of times the target repair node is generated, the unlimited generation of the target repair node can be avoided, thereby reducing system resource consumption and improving the stability of the task execution process.

[0088] In one embodiment, the above-mentioned correctness detection of the execution result includes: matching detection rules based on the task attributes of the node to be executed; and performing one or more of the following on the execution result based on each detection rule: structured field inspection, regular expression matching detection, and decision field inspection.

[0089] Here, a detection rule refers to a set of rules used to determine whether the execution result meets the requirements of the corresponding task. Since different types of tasks correspond to different execution objectives, different detection rules are required. For example, detection rules may include one or more of the following: planning detection rules, architecture detection rules, code detection rules, testing detection rules, review detection rules, deployment detection rules, and merging detection rules.

[0090] To accommodate the detection needs of different task types, each detection rule includes one or more of the following: structured field inspection, regular expression matching inspection, and decision field inspection. Structured field inspection checks the completeness, field type, and field format of preset fields in the execution result; regular expression matching inspection detects abnormal, error, or conflicting information in the execution result based on preset matching rules; and decision field inspection determines whether the corresponding task meets preset requirements based on the target decision field in the execution result.

[0091] Optionally, for different types of detection rules, you can use only one of the structured field check, regular expression matching check, and decision field check, or you can use any two or three of them in combination; at the same time, the execution order of the structured field check, regular expression matching check, and decision field check is not restricted and can be configured according to the corresponding detection rule.

[0092] In the above embodiments, by configuring corresponding detection rules for different tasks and combining structured field checks, regular expression matching detection, and decision field detection to detect the execution results, the execution results can be comprehensively judged from multiple dimensions such as field integrity, abnormal information, and task results, thereby improving the accuracy of the correctness detection results.

[0093] Furthermore, in one embodiment, the above-mentioned structured field inspection, regular expression matching inspection, and decision field inspection of the execution result based on each detection rule includes: performing structured field inspection on the execution result; performing regular expression matching inspection on the execution result after the structured field inspection passes; and performing decision field inspection on the execution result after the regular expression matching inspection passes.

[0094] Since both the decision field detection and regular expression matching detection require processing based on the target fields in the execution result, missing fields, abnormal field types, or incorrect field formats in the execution result will affect the accuracy of subsequent detection results. Therefore, in this embodiment, the detection rules are executed in a preset order.

[0095] Specifically, the execution result is first checked for structured fields to determine whether it contains preset fields and whether the corresponding fields meet the format requirements. If the structured field check passes, the execution result is checked for regular expression matching to detect whether there are preset abnormal information, error information or conflict information. If the regular expression matching check passes, the execution result is checked for judgment fields to determine whether the execution result meets the preset requirements of the corresponding task.

[0096] In the above embodiments, by checking the execution results in the order of structured field inspection, regular expression matching detection, and decision field detection, abnormal data and erroneous results can be filtered layer by layer, avoiding subsequent detection based on invalid data, thereby improving the accuracy and reliability of the correctness detection results.

[0097] In one embodiment, before obtaining the task execution graph at the currently running node, the method further includes: receiving the task to be executed; when the task to be executed is a natural language task, converting the natural language task into structured information, and splitting the task to be executed into multiple task nodes based on the structured information, and constructing a task execution graph based on the dependencies between the task nodes and the task attributes of each task node; when the task to be executed is structured information, splitting the task to be executed into multiple task nodes based on the structured information, and constructing a task execution graph based on the dependencies between the task nodes and the task attributes of each task node.

[0098] Among them, the task to be executed refers to the target task to be completed through the collaboration of multiple task nodes. It can be structured information, such as YAML format information, JSON format information, etc., or it can be natural language input.

[0099] When the task to be executed is a natural language task, since natural language descriptions are usually difficult to use directly for task scheduling, it is necessary to first parse the natural language to obtain the corresponding structured information; then, the corresponding task execution graph is generated based on the structured information.

[0100] Optionally, a planning agent performs semantic parsing on the natural language task to obtain corresponding structured task information. This structured task information includes one or more of the following: task type, target agent type, task dependencies, and task execution requirements. The structured task information is then format-validated, and the corresponding structured information is generated upon successful format validation. During output, the planning agent also generates corresponding dependency information for each task node, representing the upstream task nodes that the current task node depends on. For example, if the dependency information of task node A includes task nodes B and C, it means that task node A can only execute after task nodes B and C have completed their execution.

[0101] Optionally, when the task to be executed is structured information, the task execution graph can be generated directly based on the structured information.

[0102] Optionally, the specToGraph compiler can be used to split the task to be executed into multiple task nodes and construct a task execution graph based on the dependencies between task nodes and the task attributes of each task node.

[0103] When constructing the task execution graph, the compiler establishes dependency edges between task nodes based on their dependency information. Specifically, for any task node, it retrieves the upstream task nodes recorded in its dependency information and establishes a dependency edge pointing from the upstream task node to the current task node. After all dependency edges are established, a topology check is performed on the constructed task execution graph to determine if there are any circular dependencies. If a circular dependency exists, the current task execution graph construction is deemed to have failed, and the task execution graph is regenerated. If no circular dependency exists, the construction of the task execution graph is complete.

[0104] In the above embodiments, by simultaneously supporting natural language tasks and structured task inputs, different forms of tasks can be converted into a unified task execution graph, thereby improving the applicability and automation of the task execution process.

[0105] In one embodiment, the above-mentioned allocation of the node to be executed to the corresponding target agent based on the task attributes of the node to be executed includes: determining the candidate agents of the node to be executed based on the task attributes; calculating the execution cost of each candidate agent; and selecting the target agent from the candidate agents based on the execution cost.

[0106] In this context, a candidate agent refers to a set of agents capable of executing the corresponding node to be executed. For example, for a development task node, its candidate agents may include multiple development agents; for a review task node, its candidate agents may include multiple review agents.

[0107] Optionally, candidate proxies capable of executing the node to be executed are determined by task attributes; then, the execution cost of each candidate proxies executing the corresponding node to be executed is calculated, and the target proxies are selected from the candidate proxies based on the execution cost.

[0108] Specifically, the number of reference characters is determined based on the input information corresponding to the node to be executed, and the number of reference tokens corresponding to the number of reference characters is estimated. Then, based on the number of reference tokens and the corresponding model's fee information, the estimated execution cost of the candidate agent executing the node to be executed is calculated.

[0109] For example, the number of reference tokens is calculated as follows: Number of reference tokens = Number of reference characters / Character conversion coefficient.

[0110] For example, in one embodiment, the character conversion coefficient can be 4, meaning that on average, every 4 characters correspond to 1 token. For instance, when the input information corresponding to the node to be executed includes 4000 characters, the estimated number of reference tokens is 1000 tokens. Then, based on the number of reference tokens and the corresponding model's fee information, the estimated execution cost for the corresponding candidate agent to execute the node to be executed is calculated.

[0111] Then, based on the number of reference tokens and the corresponding model's fee information, the estimated execution cost of the corresponding candidate agent is calculated, and the target agent is selected from the candidate agents based on the estimated execution cost.

[0112] For example, when candidate agent A corresponds to the first model and candidate agent B corresponds to the second model, if the estimated execution cost of candidate agent A is lower than the estimated execution cost of candidate agent B, then candidate agent A is selected as the target agent.

[0113] In the above embodiments, by estimating the execution cost of each candidate agent before executing the node to be executed, and selecting the target agent based on the execution cost, resource consumption can be controlled while meeting the task execution requirements.

[0114] In one embodiment, after selecting a target agent from candidate agents based on execution cost, the method further includes: validating the tool name corresponding to the target agent; when the tool name passes the validity check, validating the tool permissions of the target agent based on the tool whitelist corresponding to the target agent; and when the tool permissions pass the verification, validating the path permissions of the target agent based on the path permission rules corresponding to the target path.

[0115] After the target proxy is determined, it will be verified, including: verification of the validity of the tool name, verification of tool permissions, and verification of the path.

[0116] The tool name validity check refers to performing a format check on the tool name requested by the target proxy to determine whether the tool name conforms to preset naming rules. For example, it can be determined whether the tool name conforms to preset character rules; if the tool name conforms to the preset character rules, then the tool name is deemed to have passed the validity check.

[0117] Tool permission verification refers to determining whether the target agent has the permission to invoke the corresponding tool based on the tool whitelist corresponding to the target agent. A tool is a functional component invoked by the target agent during the execution of a node, used to perform operations such as file reading, file writing, information retrieval, and terminal command execution. For example, when the target agent needs to read a target file to execute a node, it can invoke a read tool; when the target agent needs to modify a target file, it can invoke a write tool. After the target agent initiates a tool invocation request, the corresponding tool name is obtained and verified against the tool whitelist corresponding to the target agent. If the tool requested by the target agent exists in the corresponding tool whitelist, the tool permission verification is considered successful; if the tool requested by the target agent does not exist in the corresponding tool whitelist, the tool permission verification is considered unsuccessful.

[0118] Path permission verification refers to determining whether a target proxy has permission to access a target file or directory when it accesses that target file or directory through a corresponding tool, based on the path permission rules corresponding to that target path. The target path refers to the file or directory path that the target proxy calls the corresponding tool. For example, path permission rules include rules prohibiting modification, rules allowing modification, and default permission rules. When the target path meets the rule prohibiting modification, access to that target path is denied; when the target path meets the rule allowing modification, access to that target path is allowed; when the target path meets neither the rule prohibiting modification nor the rule allowing modification, access to that target path is determined according to the default permission rules.

[0119] Since subsequent verifications are all based on legitimate tool calls, this embodiment executes the verification in the following order: tool name validity, tool permission, and path permission. Specifically, first, illegal tool names are filtered out through tool name validity verification; then, tool permission verification determines whether the target proxy has permission to call the corresponding tool; finally, path permission verification determines whether the target proxy has permission to access the target path.

[0120] In the above embodiments, by verifying the target agent in the order of tool name validity verification, tool permission verification, and path permission verification, the target agent is prevented from calling unauthorized tools or accessing unauthorized paths, thereby improving the security and reliability of the task execution process.

[0121] In one embodiment, the node to be executed is a repair node; the process of the target agent executing the node to be executed includes: determining the reference node corresponding to the repair node based on the label of the repair node; obtaining the first error execution information and the first historical repair information corresponding to the reference node; obtaining the second error execution information and the second historical repair information corresponding to the same type of historical node; the same type of historical node is a task node in the task execution graph with the same task type as the reference node; generating repair reference information based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information; and executing the repair node based on the repair reference information.

[0122] When the target agent executes a repair node, it considers the reference node corresponding to the repair node when constructing the execution input, and obtains the first error execution information and the first historical repair information corresponding to the reference node. At the same time, it obtains the second error execution information and the second historical repair information corresponding to the same type of historical node in the task execution graph, and generates the corresponding repair reference information.

[0123] As mentioned above, the repair node corresponding to node B is B-1. Therefore, based on the task label, node B is used as the reference node corresponding to repair node B-1, and the first error execution information and the first historical repair information corresponding to the reference node are obtained.

[0124] Simultaneously, the task execution graph will also retrieve similar historical nodes. These similar historical nodes refer to task nodes with the same task type as the reference node that have already been successfully executed. Then, the second error execution information and second historical repair information corresponding to these similar historical nodes will be retrieved.

[0125] Subsequently, repair reference information is generated based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information.

[0126] Optionally, a globally important memory is generated based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information, and the globally important memory is used as repair reference information.

[0127] Furthermore, the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information are classified, deduplicated, and evaluated for importance. The causes of repeated errors, repair strategies, and repair results are extracted to generate corresponding global important memories.

[0128] Optionally, the repair reference information can be input to the target agent as part of the execution input for the repair node, so that the target agent can generate the corresponding repair plan based on the repair reference information and execute the repair node according to the repair plan, thereby obtaining the corresponding repair result.

[0129] In the above embodiments, by combining the error execution information, historical repair information and historical repair experience of similar historical nodes corresponding to the reference node to generate repair reference information, the target agent can refer to the effective processing methods in the historical repair process to execute the repair node, thereby improving the repair efficiency and repair success rate.

[0130] In one exemplary embodiment, combined with Figure 4 As shown, Figure 4 This is a flowchart illustrating a task orchestration method in one embodiment.

[0131] Step 402: Receive the tasks to be executed and construct the corresponding task execution graph based on the tasks to be executed.

[0132] When the task to be executed is a natural language task, the natural language task is converted into structured information, and the task to be executed is split into multiple task nodes based on the structured information. Based on the dependencies between the task nodes and the task attributes of each task node, a task execution graph is constructed.

[0133] When the task to be executed is structured information, it is divided into multiple task nodes based on the structured information, and a task execution graph is constructed based on the dependencies between task nodes and the task attributes of each task node.

[0134] Step 404: Obtain the nodes to be executed in the current running process of the task execution graph.

[0135] When the task execution graph is run for the first time, the node to be executed is the root node. Combined with... Figure 2 During the initial run, the task to be executed is node A.

[0136] As task nodes in the task execution graph are continuously completed and the task execution graph is continuously updated, the nodes to be executed in the task execution graph will change, and they may be triggered repair nodes and / or executable nodes.

[0137] Step 406: Based on the task attributes, determine the candidate proxies for the node to be executed; calculate the execution cost of each candidate proxy, and select the target proxy from the candidate proxies based on the execution cost. The target proxy is used to execute the node to be executed and output the corresponding execution result.

[0138] The specific process of selecting a target agent can be referred to the content described in the above embodiments, and will not be described in detail here.

[0139] Optionally, after determining the target proxy, the validity of the tool name corresponding to the target proxy is verified; when the tool name passes the validity verification, the tool permission of the target proxy is verified based on the tool whitelist corresponding to the target proxy; when the tool permission verification passes, the path permission of the target proxy is verified based on the path permission rules corresponding to the target path.

[0140] Specifically, when the target agent executes a repair node, the reference node corresponding to the repair node is determined based on the label of the repair node; the first error execution information and the first historical repair information corresponding to the reference node are obtained; the second error execution information and the second historical repair information corresponding to the same type of historical node are obtained; the same type of historical node is a task node in the task execution graph that has the same task type as the reference node; repair reference information is generated based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information; and the repair node is executed based on the repair reference information.

[0141] Step 408: Match the detection rules based on the task attributes of the node to be executed; perform one or more of the following on the execution results based on each detection rule: structured field inspection, regular expression matching detection, and decision field inspection.

[0142] For different types of detection rules, you can use only one of the structured field check, regular expression matching check, and decision field check, or you can use any two or three of them in combination. At the same time, the execution order of the structured field check, regular expression matching check, and decision field check is not restricted and can be configured according to the corresponding detection rule.

[0143] Optionally, the execution result is subjected to structured field checks; if the structured field checks pass, the execution result is subjected to regular expression matching checks; if the regular expression matching checks pass, the execution result is subjected to decision field checks.

[0144] Step 410: When the execution result passes the correctness check, the node to be executed is determined to have been executed successfully. Based on the node to be executed, the task execution graph is updated.

[0145] Step 412: When the execution result fails the correctness check, generate the target repair node corresponding to the node to be executed, and update the task execution graph based on the target repair node.

[0146] Step 414: Based on the updated task execution graph, continue to execute the steps of obtaining the nodes to be executed in the current running process of the task execution graph until all task nodes in the task execution graph are executed successfully.

[0147] In the above embodiments, by splitting the task to be executed into multiple task nodes with dependencies and constructing a task execution graph, the automated scheduling of complex tasks is achieved; by selecting the corresponding target agent according to the task attributes and executing the corresponding task in combination with tool permission verification and path permission verification, the security of the task execution process is improved; by performing correctness detection on the execution results and generating the corresponding target repair node when the detection fails, and by generating repair reference information in combination with historical error execution information and historical repair information, the target agent can perform targeted repair for the cause of execution failure; thereby avoiding the blockage of the entire task execution process due to the failure of a single task node, improving the overall execution efficiency of the task execution graph and the success rate of task processing.

[0148] It should be understood that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0149] Based on the same inventive concept, this application also provides a task orchestration apparatus for implementing the task orchestration method described above. The solution provided by this apparatus is similar to the implementation scheme described in the above method; therefore, the specific limitations in one or more task orchestration apparatus embodiments provided below can be found in the limitations of the task orchestration method described above, and will not be repeated here.

[0150] In one exemplary embodiment, such as Figure 5 As shown, a task orchestration device is provided, including: an acquisition module 100, a proxy allocation module 200, a verification module 300, and an iteration module 400, wherein:

[0151] The acquisition module 100 is used to acquire the nodes to be executed in the current running process of the task execution graph; the nodes to be executed include the triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for the task nodes whose execution results failed the correctness check in the previous running process; the executable nodes are task nodes whose parent nodes have all been executed successfully.

[0152] The agent allocation module 200 is used to allocate the node to be executed to the corresponding target agent according to the task attributes of the node to be executed; the target agent is used to execute the node to be executed and output the corresponding execution result.

[0153] The verification module 300 is used to check the correctness of the execution result, and when the execution result passes the correctness check, it is determined that the node to be executed has been successfully executed.

[0154] The iteration module 400 is used to update the task execution graph based on the nodes to be executed, and continue to execute the steps of obtaining the nodes to be executed in the current process of the task execution graph based on the updated task execution graph, until all task nodes in the task execution graph are executed successfully.

[0155] In one embodiment, the above-described apparatus further includes a repair node generation module, which includes:

[0156] The node generation unit is used to generate a target repair node corresponding to the node to be executed when the execution result fails the correctness check. The node to be executed is the parent node of the target repair node. The target repair node includes one or more of the error information, task output information and repair scope information corresponding to the node to be executed.

[0157] The graph update unit is used to update the task execution graph based on the target repair node.

[0158] In one embodiment, the node generation unit includes:

[0159] The count acquisition subunit is used to obtain the number of repairs corresponding to the node to be executed.

[0160] The node generation sub-unit is used to generate the target repair node corresponding to the node to be executed when the number of repairs is less than a preset threshold.

[0161] In one embodiment, the verification module 300 includes:

[0162] The rule matching unit is used to match and detect rules based on the task attributes of the node to be executed.

[0163] The quality inspection unit is used to perform one or more of the following on the execution results based on various inspection rules: structured field inspection, regular expression matching inspection, and decision field inspection.

[0164] In one embodiment, the quality inspection unit includes:

[0165] The first detection subunit is used to perform structured field checks on the execution results.

[0166] The second detection subunit is used to perform regular expression matching detection on the execution result after the structured field check has passed.

[0167] The third detection subunit is used to perform judgment field detection on the execution result based on the passing of the regular expression matching detection.

[0168] In one embodiment, the above apparatus further includes a graph construction module, which includes:

[0169] The task receiving unit is used to receive tasks to be executed.

[0170] The first building unit is used to convert the natural language task into structured information when the task to be executed is a natural language task, and to split the task to be executed into multiple task nodes based on the structured information, and to build a task execution graph based on the dependencies between the task nodes and the task attributes of each task node.

[0171] The second building unit is used to split the task to be executed into multiple task nodes based on the structured information when the task to be executed is structured information, and to build a task execution graph based on the dependency relationship between the task nodes and the task attributes of each task node.

[0172] In one embodiment, the agent allocation module 200 includes:

[0173] The candidate agent unit is used to determine the candidate agent for the node to be executed based on the task attributes.

[0174] The cost screening unit is used to calculate the execution cost of each candidate agent and select the target agent from the candidate agents based on the execution cost.

[0175] In one embodiment, the agent allocation module 200 further includes a verification unit, which includes:

[0176] The first verification subunit is used to verify the validity of the tool name corresponding to the target agent.

[0177] The second verification subunit is used to perform tool permission verification on the target agent based on the tool whitelist corresponding to the target agent when the tool name passes the validity verification.

[0178] The third verification subunit is used to perform path permission verification on the target proxy based on the path permission rules corresponding to the target path when the tool permission verification passes.

[0179] In one embodiment, the above-described apparatus further includes a proxy execution module, which includes:

[0180] The reference node determination unit is used to determine the reference node corresponding to the repair node based on the label of the repair node.

[0181] The first information acquisition unit is used to acquire the first error execution information and the first historical repair information corresponding to the reference node.

[0182] The second information acquisition unit is used to acquire the corresponding second error execution information and second historical repair information of the same type of historical nodes; the same type of historical nodes are task nodes with the same task type as the reference node in the task execution graph.

[0183] The reference repair unit is used to generate repair reference information based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information.

[0184] The execution unit is used to execute repair nodes based on the repair reference information.

[0185] Each module in the aforementioned task orchestration device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device, or stored in the memory of a computer device as software, so that the processor can call and execute the operations corresponding to each module.

[0186] In one exemplary embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 6 As shown, this computer device includes a processor, memory, input / output interfaces (I / O), and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The database stores execution results. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communication with external terminals via a network connection. When executed by the processor, the computer program implements a task scheduling method.

[0187] Those skilled in the art will understand that Figure 6 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0188] In one exemplary embodiment, a computer device is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method in any of the above embodiments.

[0189] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of the method in any of the above embodiments.

[0190] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps of the method in any of the above embodiments.

[0191] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile memory and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, artificial intelligence (AI) processors, etc., and are not limited to these.

[0192] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this application.

[0193] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A task orchestration method, characterized in that, The method includes: Obtain the nodes to be executed in the current running process in the task execution graph; the nodes to be executed include triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for task nodes whose execution results failed the correctness check in the previous run; the executable nodes are task nodes whose parent nodes have all executed successfully; Based on the task attributes of the node to be executed, the node to be executed is assigned to the corresponding target agent; the target agent is used to execute the node to be executed and output the corresponding execution result; The execution result is checked for correctness, and when the execution result passes the correctness check, the node to be executed is determined to have executed successfully. Based on the node to be executed, update the task execution graph, and continue to execute the step of obtaining the node to be executed in the current running process of the task execution graph based on the updated task execution graph, until all the task nodes in the task execution graph are executed successfully.

2. The method according to claim 1, characterized in that, The method further includes: When the execution result fails the correctness check, a target repair node corresponding to the node to be executed is generated; the node to be executed is the parent node of the target repair node; the target repair node includes one or more of the error information, task output information and repair scope information corresponding to the node to be executed. The step of updating the task execution graph based on the node to be executed includes: Update the task execution graph based on the target repair node.

3. The method according to claim 2, characterized in that, The process of generating the target repair node corresponding to the node to be executed further includes: Obtain the number of repair attempts corresponding to the node to be executed; When the number of repairs is less than a preset threshold, a target repair node corresponding to the node to be executed is generated.

4. The method according to claim 1, characterized in that, The correctness check of the execution result includes: Based on the task attribute matching detection rules of the node to be executed; Based on the aforementioned detection rules, the execution result is subjected to one or more of the following: structured field inspection, regular expression matching detection, and decision field detection.

5. The method according to claim 4, characterized in that, The step of performing one or more of the following on the execution result based on each of the aforementioned detection rules: structured field inspection, regular expression matching detection, and decision field detection: Perform structured field checks on the execution results; Based on the passing of the structured field check, regular expression matching is performed on the execution result; Based on the successful regular expression matching detection, the execution result is then subjected to field detection.

6. The method according to claim 1, characterized in that, The process of obtaining the task execution graph before the nodes to be executed in the current running process also includes: Receive tasks to be executed; When the task to be executed is a natural language task, the natural language task is converted into structured information, and the task to be executed is split into multiple task nodes based on the structured information. Based on the dependency relationship between each task node and the task attributes of each task node, the task execution graph is constructed. When the task to be executed is the structured information, the task to be executed is split into multiple task nodes based on the structured information, and the task execution graph is constructed based on the dependency relationship between each task node and the task attributes of each task node.

7. The method according to claim 1, characterized in that, The step of assigning the node to be executed to the corresponding target agent according to the task attributes of the node to be executed includes: Based on the task attributes, candidate proxies for the node to be executed are determined; Calculate the execution cost of each candidate agent, and select the target agent from the candidate agents based on the execution cost.

8. The method according to claim 7, characterized in that, After selecting the target agent from the candidate agents based on the execution cost, the method further includes: Perform a validity check on the tool name corresponding to the target agent; When the tool name passes the validity check, the tool permission check is performed on the target agent based on the tool whitelist corresponding to the target agent; When the tool's permission verification passes, the target proxy is subjected to path permission verification based on the path permission rules corresponding to the target path.

9. The method according to claim 1, characterized in that, The node to be executed is the repair node; The process by which the target agent executes the node to be executed includes: Based on the label of the repair node, determine the reference node corresponding to the repair node; Obtain the first error execution information and the first historical repair information corresponding to the reference node; Obtain second error execution information and second historical repair information corresponding to similar historical nodes; the similar historical nodes are the task nodes in the task execution graph that have the same task type as the reference node. Based on the first error execution information, the first historical repair information, the second error execution information, and the second historical repair information, repair reference information is generated; Based on the repair reference information, the repair node is executed.

10. A task orchestration device, characterized in that, The device includes: The acquisition module is used to acquire the nodes to be executed in the current running process of the task execution graph; the nodes to be executed include triggered repair nodes and / or executable nodes; the repair nodes are nodes generated for task nodes whose execution results failed the correctness check in the previous run; the executable nodes are task nodes whose parent nodes have all been executed successfully; The proxy allocation module is used to allocate the node to be executed to the corresponding target proxy according to the task attributes of the node to be executed; the target proxy is used to execute the node to be executed and output the corresponding execution result; The verification module is used to check the correctness of the execution result, and when the execution result passes the correctness check, it is determined that the node to be executed has been successfully executed; The iteration module is used to update the task execution graph based on the node to be executed, and continue to execute the step of obtaining the node to be executed in the current running process of the task execution graph based on the updated task execution graph, until all the task nodes in the task execution graph are executed successfully.

Images