Method for generating a task processing component for an agent and method for processing a task based on an agent

Abstract

The present disclosure provides a generation method of a task processing component applied to an agent and an agent-based task processing method, relates to the technical field of artificial intelligence, and particularly relates to the technical field of agents and intelligent agents. The implementation scheme is: in a plurality of historical tasks, a target task whose execution times meet a preset condition is acquired; and in response to acquiring the target task, a target task processing component corresponding to the target task is generated based on execution track information corresponding to the target task.

Description

Technical Field

[0001] This disclosure relates to the field of artificial intelligence technology, and more particularly to the field of intelligent agents and intelligent proxy technology, specifically to a method for generating a task processing component, an intelligent agent-based task processing method, apparatus, electronic device, computer-readable storage medium, and computer program product. Background Technology

[0002] Artificial intelligence (AI) is the study of enabling computers to simulate certain human thought processes and intelligent behaviors (such as learning, reasoning, thinking, and planning). It encompasses both hardware and software technologies. AI hardware technologies generally include sensors, dedicated AI chips, cloud computing, distributed storage, and big data processing. AI software technologies mainly include computer vision, speech recognition, natural language processing, machine learning / deep learning, big data processing, and knowledge graph technologies.

[0003] Currently, in the fields of computer science and artificial intelligence, two different technological paradigms have been developed for business logic processing and automated execution technologies to meet the task processing needs of various business scenarios.

[0004] On the one hand, there is rule-based workflow technology, which mainly encapsulates explicit business processes such as standard operating procedures into deterministic code logic. In practical applications, rule-based workflow technology relies on pre-structured code to provide fixed execution paths and automated task processing flows for business requirements with established rules.

[0005] On the other hand, there's agent-based extended skill technology. With the development of general artificial intelligence technologies such as large language models, this paradigm leverages the general reasoning capabilities of large language models, combined with description files, reference documents, or related script assets written in natural language, to perform dynamic task processing. In practical applications, agent-based extended skill technology can parse and process unstructured task instructions, thereby enabling dynamic task planning and execution within relatively open and complex business spaces.

[0006] The methods described in this section are not necessarily methods that had been previously conceived or adopted. Unless otherwise specified, no method described in this section should be assumed to be prior art simply because it is included in this section. Similarly, unless otherwise specified, the issues mentioned in this section should not be considered to be accepted in any prior art. Summary of the Invention

[0007] This disclosure provides a method for generating a task processing component, an agent-based task processing method, an apparatus, an electronic device, a computer-readable storage medium, and a computer program product.

[0008] According to one aspect of this disclosure, a method for generating a task processing component is provided, comprising: obtaining a target task whose execution count meets preset conditions from multiple historical tasks, wherein the execution count is obtained by statistically analyzing historical tasks with the same execution trajectory information; and in response to obtaining the target task, generating a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task, wherein the execution trajectory information includes component interface information of each task processing component used to execute the target task and execution dependencies between each task processing component, and the target task processing component includes a component description file for indicating the call interface information and execution logic of the target task processing component, wherein the target task processing component is invoked based on the parsing of the component description file by the task processing agent, wherein the call interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependencies, and the execution logic indicates the call flow of each task processing component based on the execution dependencies and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

[0009] According to another aspect of this disclosure, a task processing method based on an intelligent agent is provided, comprising: receiving task description information of a target task; generating task execution planning information by a task processing intelligent agent based on the task description information and various task processing components in a preset component library, wherein the task execution planning information is used to indicate at least one subtask to be executed to complete the target task, the task processing components corresponding to each subtask, and the execution dependencies between the subtasks; and, according to the task execution planning information, executing each subtask in the at least one subtask by calling the task processing component corresponding to the subtask to obtain the execution result of the target task, wherein the preset component library includes at least one task processing component generated based on the task processing component generation method of this disclosure.

[0010] According to another aspect of this disclosure, a task processing component generation apparatus is provided. The apparatus includes: a first acquisition unit configured to acquire a target task whose execution count meets a preset condition from multiple historical tasks, wherein the execution count is obtained by statistically analyzing historical tasks with the same execution trajectory; and a first generation unit configured to, in response to acquiring the target task, generate a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task. The execution trajectory information includes component interface information of each task processing component used to execute the target task and execution dependencies between each task processing component. The target task processing component includes a component description file for indicating the call interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The call interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependencies. The execution logic indicates the call flow of each task processing component based on the execution dependencies and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

[0011] According to another aspect of this disclosure, a task processing apparatus based on an intelligent agent is provided. The apparatus includes: a first receiving unit configured to receive task description information of a target task; a first generating unit configured to generate task execution planning information through a task processing intelligent agent based on the task description information and various task processing components in a preset component library, wherein the task execution planning information indicates at least one subtask to be executed to complete the target task, the task processing components corresponding to each subtask, and the execution dependencies between the subtasks; and a first execution unit configured to execute each subtask in the at least one subtask by calling the task processing component corresponding to the subtask, in order to obtain the execution result of the target task, wherein the preset component library includes at least one task processing component generated based on the task processing component generation method of this disclosure.

[0012] According to another aspect of this disclosure, an electronic device is provided, comprising: 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, the instructions being executed by the at least one processor to enable the at least one processor to perform a method for generating a task processing component of this disclosure or a task processing method based on an intelligent agent.

[0013] According to another aspect of this disclosure, a non-transitory computer-readable storage medium storing computer instructions is provided, wherein the computer instructions are used to cause a computer to execute a method for generating a task processing component of this disclosure or an agent-based task processing method.

[0014] According to another aspect of this disclosure, a computer program product is provided, including a computer program, wherein the computer program, when executed by a processor, implements the method for generating a task processing component of this disclosure or an agent-based task processing method.

[0015] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0016] The accompanying drawings exemplify embodiments and form part of the specification, serving together with the textual description to explain exemplary implementations of the embodiments. The illustrated embodiments are for illustrative purposes only and do not limit the scope of the claims. Throughout the drawings, the same reference numerals refer to similar but not necessarily identical elements.

[0017] Figure 1 A schematic diagram of an exemplary system in which the various methods described herein may be implemented according to embodiments of the present disclosure is shown; Figure 2 A flowchart illustrating a method for generating a task processing component according to an embodiment of the present disclosure is shown; Figure 3 A schematic diagram illustrating the invocation methods of different execution-state components according to exemplary embodiments of the present disclosure is shown; Figure 4 A flowchart illustrating a target task processing component according to an embodiment of the present disclosure is shown; Figure 5 A flowchart illustrating a target task processing component according to an embodiment of the present disclosure is shown; Figure 6 A flowchart illustrating the generation of a target script file according to an embodiment of the present disclosure is shown; Figure 7 A flowchart of an agent-based task processing method according to an embodiment of the present disclosure is shown; Figure 8 A flowchart illustrating the execution of subtasks according to embodiments of the present disclosure is shown; Figure 9 A flowchart illustrating the execution of subtasks according to embodiments of the present disclosure is shown; Figure 10 A flowchart of a target task processing component generated according to an exemplary embodiment of the present disclosure is shown; Figure 11 A structural block diagram of a task processing component generation apparatus according to an embodiment of the present disclosure is shown; Figure 12A structural block diagram of an agent-based task processing apparatus according to an embodiment of the present disclosure is shown; Figure 13 A structural block diagram of an exemplary electronic device that can be used to implement embodiments of the present disclosure is shown. Detailed Implementation

[0018] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0019] In this disclosure, unless otherwise stated, the use of terms such as "first," "second," etc., to describe various elements is not intended to limit the positional, temporal, or importance relationships of these elements; such terms are merely used to distinguish one element from another. In some examples, the first element and the second element may refer to the same instance of that element, while in other cases, based on the context, they may refer to different instances.

[0020] The terminology used in the description of the various examples described in this disclosure is for the purpose of describing particular examples only and is not intended to be limiting. Unless the context explicitly indicates otherwise, an element may be one or more unless the number of elements is specifically limited. Furthermore, the term "and / or" as used in this disclosure covers any one of the listed items and all possible combinations thereof.

[0021] In related technologies, there are two main, diametrically opposed approaches to handling and automating complex business logic. One approach involves the agent performing complex task decomposition, node planning, and component scheduling from scratch each time. The other relies on developers manually writing code based on prior experience to encapsulate fixed task flows. The former not only continuously consumes significant computational power and time for large-scale model inference but is also prone to inconsistencies in execution paths and high error rates due to the inherent instability of generative models. The latter, on the other hand, has high development and maintenance costs and struggles to dynamically and adaptively refine the underlying complex task flow logic based on the system's actual operating conditions, severely limiting the agent system's self-evolution and generalization capabilities.

[0022] The embodiments of this disclosure provide a method for generating a task processing component. First, tasks with identical execution trajectory information are statistically analyzed across multiple historical tasks to filter out target tasks that meet the execution frequency criteria. Then, based on the execution dependencies and component interface information of the underlying task processing components, the exposed call interface information of the large component is automatically identified, and an execution logic containing both the call flow (control flow) and parameter passing relationships (data flow) is constructed. Both are then encapsulated in a component description file to generate the target task processing component corresponding to the target task. When the task processing agent subsequently encounters the target task again, it only needs to parse the component description file to execute the entire complex process. This achieves automatic encapsulation and efficient reuse of high-frequency task processing flows, improving the agent's task execution efficiency, accuracy, and stability, and reducing the agent's inference cost.

[0023] The embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0024] Figure 1 A schematic diagram of an exemplary system 100 in which the various methods and apparatus described herein can be implemented according to embodiments of this disclosure is shown. Reference Figure 1 The system 100 includes one or more client devices 101, 102, 103, 104, 105 and 106, a server 120, and one or more communication networks 110 coupling the one or more client devices to the server 120. The client devices 101, 102, 103, 104, 105 and 106 can be configured to execute one or more applications.

[0025] In embodiments of this disclosure, server 120 may run one or more services or software applications that enable the generation method of the task processing components of this disclosure or the agent-based task processing method to perform.

[0026] In some embodiments, server 120 may also provide other services or software applications, which may include non-virtual and virtual environments. In some embodiments, these services may be provided as web-based services or cloud services, such as to users of client devices 101, 102, 103, 104, 105 and / or 106 under a Software as a Service (SaaS) model.

[0027] exist Figure 1In the configuration shown, server 120 may include one or more components that implement the functions performed by server 120. These components may include software components, hardware components, or combinations thereof that can be executed by one or more processors. Users operating client devices 101, 102, 103, 104, 105, and / or 106 can sequentially interact with server 120 using one or more client applications to utilize the services provided by these components. It should be understood that various different system configurations are possible and may differ from system 100. Therefore, Figure 1 This is an example of a system used to implement the various methods described herein, and is not intended to be limiting.

[0028] Users can use client devices 101, 102, 103, 104, 105, and / or 106 to upload task description information to initiate a task request. The client devices can provide an interface that allows users to interact with the client devices. The client devices can also output information to the user through this interface. Although... Figure 1 Only six client devices are described, but those skilled in the art will understand that this disclosure can support any number of client devices.

[0029] Client devices 101, 102, 103, 104, 105, and / or 106 may include various types of computer devices, such as portable handheld devices, general-purpose computers (such as personal computers and laptops), workstation computers, wearable devices, smart screen devices, self-service terminal devices, service robots, gaming systems, thin clients, various messaging devices, sensors, or other sensing devices. These computer devices can run various types and versions of software applications and operating systems, such as Microsoft Windows, Apple iOS, UNIX-like operating systems, Linux or Linux-like operating systems (such as Google Chrome OS); or include various mobile operating systems, such as Microsoft Windows Mobile OS, iOS, Windows Phone, and Android. Portable handheld devices may include cellular phones, smartphones, tablets, personal digital assistants (PDAs), etc. Wearable devices may include head-mounted displays (such as smart glasses) and other devices. Gaming systems may include various handheld gaming devices, internet-enabled gaming devices, etc. Client devices are capable of executing various applications, such as various internet-related applications, communication applications (such as email applications), short message service (SMS) applications, and can use various communication protocols.

[0030] Network 110 can be any type of network well known to those skilled in the art, and can support data communication using any of a variety of available protocols (including but not limited to TCP / IP, SNA, IPX, etc.). By way of example only, one or more networks 110 can be a local area network (LAN), an Ethernet-based network, a token ring network, a wide area network (WAN), the Internet, a virtual network, a virtual private network (VPN), an intranet, an extranet, a blockchain network, a public switched telephone network (PSTN), an infrared network, a wireless network (e.g., Bluetooth, WIFI), and / or any combination of these and / or other networks.

[0031] Server 120 may include one or more general-purpose computers, special-purpose server computers (e.g., PC (personal computer) servers, UNIX servers, mid-range servers), blade servers, mainframe computers, server clusters, or any other suitable arrangement and / or combination. Server 120 may include one or more virtual machines running a virtual operating system, or other computing architectures involving virtualization (e.g., one or more flexible pools of logical storage devices that can be virtualized to maintain virtual storage devices for servers). In various embodiments, server 120 may run one or more services or software applications that provide the functionality described below.

[0032] The computing unit in server 120 can run one or more operating systems, including any of the aforementioned operating systems and any commercially available server operating system. Server 120 can also run any of a variety of additional server applications and / or middleware applications, including HTTP servers, FTP servers, CGI servers, JAVA servers, database servers, etc.

[0033] In some implementations, server 120 may include one or more applications to analyze and merge data feeds and / or event updates received from users of client devices 101, 102, 103, 104, 105 and / or 106. Server 120 may also include one or more applications to display data feeds and / or real-time events via one or more display devices of client devices 101, 102, 103, 104, 105 and / or 106.

[0034] In some implementations, server 120 can be a server for a distributed system or a server integrated with blockchain. Server 120 can also be a cloud server, or an intelligent cloud computing server or intelligent cloud host with artificial intelligence technology. A cloud server is a host product in the cloud computing service system, designed to address the shortcomings of traditional physical hosts and Virtual Private Server (VPS) services, such as high management difficulty and weak business scalability.

[0035] System 100 may also include one or more databases 130. In some embodiments, these databases may be used to store data and other information. For example, one or more of the databases 130 may be used to store information such as audio files and video files. Databases 130 may reside in various locations. For example, a database used by server 120 may be local to server 120, or it may be located away from server 120 and may communicate with server 120 via a network-based or dedicated connection. Databases 130 may be of different types. In some embodiments, the database used by server 120 may be, for example, a relational database. One or more of these databases may store, update, and retrieve data from and from the databases in response to commands.

[0036] In some embodiments, one or more of the databases 130 may also be used by an application to store application data. The databases used by the application may be of different types, such as key-value stores, object stores, or regular stores supported by a file system.

[0037] Figure 1 The system 100 can be configured and operated in various ways to enable the application of the various methods and apparatus described in this disclosure.

[0038] According to embodiments of this disclosure, such as Figure 2 As shown, a method for generating a task processing component is provided, including: step S201, obtaining a target task whose execution count meets preset conditions from multiple historical tasks, wherein the execution count is obtained by statistically analyzing historical tasks with the same execution trajectory information; and step S202, in response to obtaining the target task, generating a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task. The execution trajectory information includes component interface information of each task processing component used to execute the target task and the execution dependencies between each task processing component. The target task processing component includes a component description file that indicates the calling interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The calling interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependencies. The execution logic indicates the calling flow of each task processing component based on the execution dependencies and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

[0039] Therefore, by first statistically analyzing tasks with identical execution trajectory information across multiple historical tasks, "target tasks" meeting the execution frequency criteria are selected. Subsequently, through the execution dependencies and component interface information of the underlying task processing components, the call interface information exposed by the large component is automatically identified, and an execution logic containing both the call flow (control flow) and parameter passing relationships (data flow) is constructed. Both are then encapsulated in a component description file to generate the target task processing component corresponding to the target task. When the task processing agent encounters the target task again, it only needs to parse the component description file to execute the entire complex process. This achieves automatic encapsulation and efficient reuse of high-frequency task processing processes, improving the agent's task execution efficiency, accuracy, and stability, and reducing the agent's inference cost.

[0040] In some embodiments, the historical task may refer to a task instance that the system executed in the past when responding to a received task request.

[0041] In some embodiments, the system receives task description information from the task initiator, which is typically expressed in natural language. Based on this task description information and various task processing components in a pre-defined component library, the task processing agent generates task execution planning information through understanding and planning. This task execution planning information can indicate at least one subtask required to complete the target task, the corresponding task processing components for each subtask, and the execution dependencies between the subtasks. Subsequently, the task processing agent can, based on the aforementioned execution dependencies, sequentially execute each subtask by calling the corresponding task processing components, obtain the task execution result, and return it to the task initiator.

[0042] In some embodiments, the task execution planning information described above can be generated as a to-do list description file (tasks / todo.md), in which the subtasks to be executed at each stage of the task and the task processing components to be invoked can be described in natural language.

[0043] In some embodiments, the task execution planning information may further include instruction text for creating an agent, which instructs the task processing agent to first create a sub-agent when executing each sub-task, send the input data corresponding to the sub-task to the sub-agent, have the sub-agent call the corresponding task processing component to complete the sub-task, and then return the corresponding output result to the task processing agent.

[0044] In some embodiments, the system may simultaneously record relevant information about the task execution trajectory during the execution of the above tasks.

[0045] In some embodiments, a predefined script file for recording task execution information can be invoked to record task execution information in the historical task execution record during task execution.

[0046] In some embodiments, the task execution information recorded above may include, but is not limited to, task identifier, task description information, timestamp, execution status (success or failure, etc.), task identifier of each subtask (e.g., recorded as step number), identifier of the called task processing component, input data, output data, and dependency identifiers between subtasks.

[0047] In some exemplary embodiments, the dependency identifiers between the above subtasks can be recorded as the depends_on field. For example: depends_on: [] indicates no prerequisite dependencies and can be executed in parallel; depends_on: [1] indicates that it depends on subtask 1 and must be executed after subtask 1 is completed; depends_on: [1, 2] depends on both subtask 1 and subtask 2 and must be executed after both are completed.

[0048] In some embodiments, the system can persistently save the aforementioned task execution information to a specific log file (historical task execution record) using a specific structured text format. For example, JSON format can be used, and the information can be stored in the historical task execution record in JSONL format, with one task execution record per line. The persistent historical task execution record not only provides a basis for task backtracking but also provides a data source for high-frequency pattern recognition. Subsequently, by analyzing the task execution trajectory information (task execution topology) in these records, successful execution patterns and typical input / output examples can be identified, thereby supporting the automatic generation of subsequent target task processing components and the evolution of system capabilities.

[0049] In some embodiments, to obtain a target task whose execution count meets a preset condition among multiple historical tasks, the system can first read the task execution information of all historical tasks from the aforementioned historical task execution records. In some embodiments, when obtaining multiple historical tasks from the historical task log, it can also be that only multiple historical tasks with a successful execution status are obtained. Based on this, the system further extracts the execution trajectory information (i.e., the abstract task execution topology) corresponding to each historical task from the aforementioned task execution information. This extraction process may include steps such as pattern extraction and normalization calculation.

[0050] In some embodiments, to eliminate interference from specific business data on pattern recognition, pattern extraction can first be performed on each task execution information to obtain the corresponding abstract execution pattern. Specifically, the identifiers (i.e., component names) of each task processing component called in the task execution information and the execution dependencies between each task processing component can be extracted. Simultaneously, the specific input and output parameter values ​​in the component interface information of each task processing component can be replaced with the corresponding abstract type information (Schema data type). For example, the actual string values ​​of the specific input username or password can be uniformly replaced with a general string type identifier. Through this pattern extraction process, the system can transform specific execution records containing specific values ​​into abstract execution patterns that only reflect the underlying task processing logic and data structure.

[0051] After obtaining the above abstract execution pattern, it can be further normalized to obtain the corresponding execution trajectory information. Specifically, the above abstract execution pattern can be topologically sorted to eliminate the randomness of the recording order of parallel tasks.

[0052] In the original logs, if multiple task processing components do not have execution dependencies, they are often initiated in parallel during actual operation. This may result in the same business process appearing in different execution logs with different ordering sequences. To ensure that the same business process generates a unique hash value subsequently, the system can introduce a deterministic topology sorting mechanism. First, the system determines the hierarchy between components based on execution dependencies, for example, placing dependent components first. Second, for parallel task processing components (i.e., components without mutual dependencies), the system uses a deterministic sorting rule (e.g., alphabetical order of task processing component names) to determine their absolutely unique order. Through this process, regardless of the physical order in the original logs, the normalized component sequence remains unique.

[0053] In some embodiments, after determining the absolutely unique component call order, the steps of renumbering and generating standard labels can be performed. Specifically, the step numbers in the original trajectory can be removed, and standardized node labels (e.g., Node_0, Node_1, etc.) can be reassigned according to the sorted order. The dependency pointers between nodes are also updated synchronously to point to the corresponding standardized labels. Finally, the system converts the processed node information (including standardized labels, task processing component identifiers, component interface information, and updated execution dependencies) into a strictly standardized text string, which serves as the final execution trajectory information.

[0054] In some embodiments, after each task is completed, the task processing agent or the underlying recording component can directly save the processed execution trajectory information in the historical task execution record at runtime. Thus, in the subsequent evolutionary statistics phase, the system can directly read the abstracted execution trajectory information from the historical task execution record for frequency statistics, thereby eliminating the need for repeated post-calculation and extraction steps and further reducing the system's processing overhead.

[0055] In some embodiments, after obtaining the execution trajectory information of each historical task from multiple historical tasks, a hash calculation (e.g., calculating a SHA256 hash value) can be performed on each execution trajectory information separately, and the calculated hash value can be used as a unique trajectory identifier for the execution trajectory information of that historical task. Thus, even if the originally generated subtask numbers or execution times differ in different historical task instances, as long as their underlying component call topology and parameter types are the same, a consistent unique trajectory identifier can be generated.

[0056] In some embodiments, the number of historical tasks with the same trajectory identifier (i.e., the same execution trajectory information) in multiple historical tasks can be counted to determine the number of times the historical task is executed in history. When the number of executions is greater than a certain preset threshold (a first preset threshold, for example, 10 times), the historical task is determined as the target task that needs to be generated by the task processing component.

[0057] After obtaining the target task, a target task processing component can be generated based on the execution trajectory information corresponding to the target task. The target task processing component includes a component description file that indicates the calling interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The calling interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependency relationship. The execution logic indicates the calling flow of each task processing component based on the execution dependency relationship and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

[0058] In some embodiments, the aforementioned target task processing component refers to a reusable, standardized task processing module generated by the system's automatic encapsulation mechanism for frequently occurring target tasks detected in the above manner. This target task processing component integrates the complex execution process, which originally required multiple inferences and plans, into a unified overall abstraction layer, providing a single entry point. In this way, when faced with similar tasks, the task processing agent can directly invoke the complex business process as if calling a basic task processing component, thereby greatly avoiding repetitive planning, logic decomposition, and corresponding computational consumption.

[0059] In some embodiments, the aforementioned component description file can be used to explicitly declare to the task processing agent the external call boundaries (i.e., call interface information) and internal flow mechanisms (i.e., execution logic) of the target task processing component. The call interface information of the target task processing component can be used to define the global input parameters received by the component as a whole and the global output parameters returned to the outside; the execution logic is used to define the control flow and data flow contained within the component.

[0060] The aforementioned API call information can be obtained by systematically sorting out the component interface information of each internal task processing component based on the execution dependencies in the execution trajectory information. For example, the system can traverse along the dependency topology, extract all input parameters that are not covered by the output data of any preceding component, and use them as global input parameters for the target task processing component; and use the output of components at the end of the topology or marked as key results as global output parameters.

[0061] Furthermore, the aforementioned execution logic can be automatically generated based on execution trajectory information. On one hand, based on the aforementioned execution dependencies, this execution logic explicitly indicates the sequential calling flow of each internal task processing component (i.e., control flow, indicating which components can run in parallel and which must wait sequentially); on the other hand, based on the component interface information of each internal task processing component, this execution logic explicitly indicates the parameter passing relationship between each task processing component (i.e., data flow, for example, specifically indicating how to accurately map the output parameters of the preceding component and pass them to the following component as input parameters).

[0062] In some embodiments, the target task processing component can be invoked based on the parsing of the component description file by the task processing agent. When the task processing agent subsequently receives a task request that matches the target task again, or determines that one of the subtasks in a task request matches the target task, the agent does not need to reuse the underlying large language model to perform task planning and decomposition from scratch, but directly loads and parses the aforementioned component description file.

[0063] The task processing agent first extracts the corresponding global input data from the current task description based on the parsed API call information. Then, strictly following the call flow and parameter passing relationships indicated in the parsed execution logic, the agent sequentially schedules the underlying task processing components (e.g., dispatching tasks to sub-agents on demand) and ensures accurate data transfer between internal components. Finally, after all underlying processes are completed, the agent extracts and returns the final task execution result according to the API call information. This transforms implicit execution experience into structured assets that the agent can directly read and execute according to instructions.

[0064] In some embodiments, the generation process of the aforementioned task processing components can be automatically executed by an independent, resident background process in the system (e.g., an evolution engine). This background process is independent of the task receiving and scheduling processes and can periodically perform statistical analysis on the aforementioned historical task execution records, thereby automatically converting frequently occurring execution trajectories into corresponding task processing components.

[0065] In some embodiments, the background process may employ a timed polling mechanism, for example, configured to execute an evolution cycle every fixed interval (e.g., every hour). Within each evolution cycle, the background process primarily performs the following operations: First, the background process can traverse all historical task execution records stored in the system and extract the execution trajectory information of each historical task. It then uses an internal frequency analyzer to count the number of executions for each type of execution trajectory. When the number of executions for a certain type of execution trajectory meets a preset condition (e.g., exceeding a first preset threshold), the background process can trigger a component generation process, automatically creating a new task processing component directory containing component description files, thereby completing the generation and storage of the target task processing component.

[0066] In some embodiments, the background process can also persistently save the results of this evolution operation, the generation time, and related component information to a dedicated evolution log file for subsequent system auditing and evolution status tracking.

[0067] In some embodiments, the target task processing component described above may be generated as a first execution state or a second execution state (corresponding to a first execution state component or a second execution state component, respectively).

[0068] The first execution-state component invokes other underlying task processing components through natural language descriptions in its component description file (i.e., the first description file). This descriptions include the component's overall input and output (call interface information), as well as the invocation methods, inputs and outputs, and dependencies (execution logic) of each other underlying task processing component. This information is understood and implemented by the task processing agent at runtime. In addition to the aforementioned first description file, the first execution-state component may also contain code script files used only for implementing functionality at a specific stage of its own process (these code script files cannot be invoked or executed across components). Because the generation of the first execution-state component does not require modification of the underlying code, the business processes in the first description file can be modified or adjusted at any time, providing greater flexibility.

[0069] The second execution-state component calls other underlying task processing components by directly writing specific business logic into code script files. When the task processing agent calls such a component, it can directly execute its code script file to complete the corresponding task. Its component description file can include a second description file and a code script file (i.e., the target script file of this disclosure). The second description file can describe the overall input and output (call interface information) of the component using natural language, and instruct the task processing agent to execute the target script file at runtime (this script file explicitly defines the calls, inputs, outputs, and dependencies of the code script files for each other underlying task processing component, i.e., the execution logic), to achieve the execution of the corresponding task. The second execution-state component eliminates the agent's reasoning in task decomposition and execution, making the execution path fixed, improving task response efficiency, and avoiding the impact on task execution accuracy caused by the agent's illusions or other factors.

[0070] As an example, the above code script file or target script file can be an executable file such as a shell script, binary executable file, or Python script, and there are no restrictions here.

[0071] Figure 3 A schematic diagram illustrating the invocation methods of different execution-state components according to exemplary embodiments of the present disclosure is shown.

[0072] In some exemplary embodiments, such as Figure 3 As shown, for the same target task, its target task processing component may include at least one of a first execution state component and a second execution state component. If the target task is executed in the first execution state, the task processing agent can parse its first description file, create sub-agents for each underlying task processing component it calls, and the corresponding sub-agents call the corresponding components to complete the execution of the target task. If the target task is executed in the second execution state, the task processing agent can create operating system sub-processes for each underlying task processing component based on the target script text in the second description file, and call and execute the code script files of the corresponding components through the operating system sub-processes to complete the execution of the target task.

[0073] In some embodiments, relevant personnel may determine, based on actual needs, whether to generate the target task processing component as a first execution state component or a second execution state component.

[0074] In some embodiments, such as Figure 4As shown, in response to obtaining the target task, generating a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task may include: step S401, in response to determining that there is no task processing component corresponding to the target task in the preset component library, generating a first execution state component corresponding to the target task, the first execution state component including a first description file, the generation of the first description file including: step S4011, based on the execution dependency relationship, sorting out the component interface information of each task processing component used to execute the target task to obtain the call interface information; and step S4012, based on the call interface information and the execution trajectory information, generating a first description file, wherein the first description file includes a first instruction text described in natural language to indicate the call interface information and execution logic; and step S402, determining the first description file as a component description file, and determining the first execution state component as the target task processing component corresponding to the target task.

[0075] Therefore, by generating a first execution-state component containing a first instruction text (call interface information and execution logic described in natural language) based on execution dependencies and component interface information when it is determined that there is no corresponding component for the target task in the preset component library, the complex task flow that initially shows high frequency characteristics can be quickly and lightweightly encapsulated into a task processing component that can be read by the agent. This provides the system with preliminary reusability without intruding on or modifying the code script, effectively reducing the reasoning cost of the agent and improving the execution efficiency of the agent.

[0076] In some exemplary embodiments, the generation of the first execution-state component may include the following steps: 1) Generate the name of the first execution state component: As an example, it can be automatically generated by combining the names of the various task processing components it calls, for example, generating "auth-query" based on "user-auth" and "user-info-query"; 2) Generating the first description file may include: based on the execution dependencies in the execution trajectory information, sorting out the component interface information of each task processing component used to execute the target task, and obtaining the overall call interface information of the first execution state component. Subsequently, based on the execution trajectory information, generating the execution logic of each task processing component called by the first execution state component, and using the aforementioned call interface information and execution logic as the first instruction text of the first description file, thus generating the first description file. As one exemplary method, the first description file can be generated by filling the call interface information and execution trajectory information into a preset description file template; as another exemplary method, a large language model can be used to generate the first description file according to a predefined description format.

[0077] As an example, the API call information and execution logic in the first description file can be organized into the following form: Phase Description: Phase 0: Extracting Input Parameters (Describe which parameters need to be extracted from the task description information or upstream tasks); Stages 1-N: Calls to underlying task processing components, including stage goals, input sources, execution commands (including commands to call underlying task processing components, commands to assign input parameters of the component to the input interface of the component), output parameter lists, etc. Stage N+1: Format the output (e.g., describe how to convert the output of the final stage into natural language).

[0078] In some exemplary embodiments, the first description file may also include, but is not limited to, the following other information: metadata such as the name of the first execution state component, task description information, generation time, and historical execution count; functional description of the first execution state component, such as the task processing component it calls, the implemented business process, execution trajectory information (execution topology), etc.; usage examples, such as typical cases extracted from actual execution examples, etc.

[0079] 3) Create the directory and files for the first execution state component: For example, a new task processing component directory can be created under a certain component directory, and the first description file generated above can be written into that directory.

[0080] In some embodiments, the first description file may further include a second instruction text, which may be used to instruct the creation of a sub-agent corresponding to the task processing component before invoking the respective task processing component for executing the target task, so as to invoke the task processing component through the sub-agent.

[0081] In some exemplary embodiments, a second instruction text (e.g., "completed by a sub-agent") may be added before the description of the input parameters for each of stages 1 to N in the stage description of the first description file described above, so that when the task processing agent executes the target task according to the first description file, it creates a sub-agent before calling each task processing component, and calls the task processing component through the sub-agent.

[0082] Therefore, by adding a second instruction text to the first description file to indicate the creation of sub-agents, logical decoupling and sub-scheduling of complex tasks during execution are achieved. This enables the main agent (task processing agent) to execute tasks in a hierarchical multi-agent collaborative architecture, effectively avoiding context overload or logical illusion when a single agent is dealing with a lengthy call chain, and further improving the stability and accuracy of task execution.

[0083] In some embodiments, the method for generating the task processing component may further include: adding the first execution state component as the target task processing component corresponding to the target task to a preset component library.

[0084] Thus, by adding the first execution-state component as the target task processing component to the preset component library, unified management and persistent accumulation of high-frequency task processing assets are achieved. This enables the system to directly retrieve and call upon the component library when faced with similar tasks in the future, continuously enriching and solidifying the underlying capabilities of the intelligent agent system.

[0085] In some embodiments, such as Figure 5 As shown, the aforementioned preset conditions may include the number of times the target task is executed being greater than a first preset threshold. In response to obtaining the target task, generating a target task processing component based on the execution trajectory information corresponding to the target task may include: step S501, in response to determining that the number of executions is greater than a second preset threshold and that the task processing component corresponding to the target task in the preset component library is a first execution-state component, generating a second execution-state component corresponding to the target task. The second preset threshold is greater than the first preset threshold. The second execution-state component includes a second description file and a target script file. The generation of the second description file and the target script file may include: step S5011, parsing the first description file of the first execution-state component to... Step S5012: Extract the call interface information; Step S5013: Obtain the execution script files of each task processing component used to execute the target task; Step S5014: Generate the target script file based on the execution trajectory information and the execution script files of each task processing component; Step S5015: Generate a second description file based on the call interface information and the target script file, wherein the second description file includes a third instruction text described in natural language to indicate the call interface information and the call operation for the target script file; and Step S502: Determine the second description file and the target script file as component description files, and determine the second execution state component as the target task processing component corresponding to the target task.

[0086] Therefore, when the number of times the target task occurs reaches a higher second preset threshold (e.g., 100 times), the call interface information of the first execution state component is parsed and extracted, and combined with the underlying execution script file to generate a second execution state component containing the target script file and the second description file. This achieves the automatic transformation of the component form from natural language scheduling to direct execution based on code logic. While maintaining seamless compatibility with external interfaces, the cumbersome internal node scheduling is directly controlled by the script code, further reducing the inference cost of the agent, improving the execution efficiency of the agent, and enhancing the stability and accuracy of task execution.

[0087] In some embodiments, such as Figure 6 As shown, generating a target script file based on execution trajectory information and the respective execution script files of each task processing component may include: Step S601, determining the parameter sources of each task processing component used to execute the target task based on execution dependencies, where the parameter sources include the output of the previously executed task processing component or the global input of the target task; Step S602, converting the variables corresponding to the parameter sources of each task processing component into command-line parameters for calling the corresponding execution script file of the task processing component based on the component interface information; and Step S603, filling the calling paths and command-line parameters of the execution script files corresponding to each task processing component into a preset code template according to the calling order indicated by the execution dependencies to generate the target script file, whereby the target script file passes the data from the parameter sources to the corresponding execution script file through command-line parameters when it is executed.

[0088] Therefore, by clarifying the parameter sources of each underlying task processing component, converting the variables corresponding to the parameter sources into command-line parameters, and filling them into the preset code template according to the calling order to generate the target script file, the accurate mapping of data flow and control flow in the underlying code generation process is achieved, ensuring that the generated target script file can correctly complete data transmission, and guaranteeing the stability and accuracy of the second execution state component during actual execution.

[0089] In some exemplary embodiments, the generation of the second execution state component may include the following steps: 1) Parse the first description file in the first execution state component corresponding to the target task and extract the call interface information therein.

[0090] 2) Obtaining Execution Trajectory Information: As one exemplary implementation, the execution trajectory information can be obtained in the manner described above; as another exemplary implementation, the execution trajectory information can also be directly extracted from the first description file mentioned above. The execution trajectory information may include component interface information of each task processing component used to execute the target task and the execution dependencies between each task processing component. Specifically, it may include: the name of each task processing component, component interface information (e.g., including parameter names, data types, data structures, etc. of input parameters and output parameters), and the execution dependencies between each task processing component.

[0091] 3) Generate the target script file, which may include: ① Based on the above execution dependencies, the parameter sources for each task processing component used to execute the target task are determined. Specifically, for each execution stage (i.e., each underlying task processing component) that constitutes the target task, the system checks its corresponding dependency field (e.g., the depends_on field): if the field is empty, it means that the current component is in the initial stage, and its input parameters are directly from the global input of the target task; if the field is not empty, the system iterates through the preceding stage numbers it depends on, extracts parameters from the output variables of the corresponding preceding stage's task processing component, and uses them as the parameter source for the current component.

[0092] For example, assuming stage 2 depends on stage 1, then the input parameters of stage 2 come directly from the output of stage 1. An example code transformation logic is as follows: "# The input parameters for stage 2 come from the output of stage 1." token = token_step1 user_id = user_id_step1” ② Based on the component interface information of each task processing component, convert the variables corresponding to the parameter sources of that task processing component into command-line arguments used to call the corresponding execution script file of that task processing component. Since the underlying task processing components usually receive input via the command line during actual runtime, it is necessary to convert the internal program variables into a parameter list that conforms to the command-line calling specification. During the conversion process, the system can automatically convert the underscore format in the variable name to the hyphen format (for example, convert the internal variable user_id to the command-line argument --user-id).

[0093] An example of a command that can be transformed and made into a cross-script call is shown below: "subprocess.run(['python3', script_path, '--username', username, '--password', password], ...)" ③ Fill the call path of the execution script file corresponding to each task processing component and the command line parameters generated above into the preset code template according to the calling order indicated by the execution dependency relationship to generate the final target script file.

[0094] In some exemplary embodiments, to generate standardized and readable code files, the code generator internally maintains the aforementioned preset code template. This preset code template can predefine the file header and standard library imports (e.g., importing modules like json and argparse), the main execution function framework, the assembly logic for returning the final result, and the main function entry point for defining and parsing command-line arguments. The system inserts the extracted component variables into placeholders in the template through string formatting and other operations.

[0095] For example, the stage call code block in this preset code template can be as follows: # ========== Stage {stage_num}: Call {skill_name} ========== {skill_var}_script = skills_root / '{skill_name}' / 'scripts' / 'executor.py' stage{stage_num}_result = subprocess.run([...], ...) # Error handling and output parsing... The above-mentioned template-based generation method not only ensures the consistency and maintainability of the generated code, but also ensures that when the target script file is actually executed, it can strictly trigger each underlying stage in the topological order, and accurately pass the data from the parameter source to the corresponding underlying execution script file through the above command line parameters, thereby completing the deterministic code solidification of complex business logic.

[0096] 4) Generating a second description file may include: using the aforementioned API call information and the instructions for calling the aforementioned target script file as the third instruction text of the second description file to generate the second description file. As one exemplary method, the second description file can be generated by filling the API call information and the path information of the second script file into a preset description file template; as another exemplary method, a large language model can be used to generate the second description file according to a predefined description format.

[0097] As an example, the second description file can be organized into the following form: Phase Description: Phase 0: Extracting Input Parameters (Describe which parameters need to be extracted from the task description information or upstream tasks); Phase 1: Describe how to call and execute the target script file; Phase 2: Format the output (e.g., describe how to convert the output of the final phase into natural language).

[0098] 5) Create the directory and files for the second execution state component: For example, a new task processing component directory can be created under a certain component directory, and the second description file and target script file generated above can be written into that directory.

[0099] In some embodiments, the preset code template may also include subprocess creation commands corresponding to each task processing component used to execute the target task. The subprocess creation commands can be used to create new operating system subprocesses to execute commands in the execution script file corresponding to the task processing component.

[0100] Therefore, by introducing the command to create a new operating system subprocess (subprocess.run) into the preset code template, process-level isolation between various underlying task processing components is achieved at the code execution level. This effectively avoids dependency conflicts or memory leaks when different components run in the same memory space, and improves the security and concurrency stability of the entire task flow execution.

[0101] In some embodiments, the method for generating the task processing component may further include: adding the second execution state component as the target task processing component corresponding to the target task to a preset component library.

[0102] Therefore, by adding the second execution state component to the preset component library, the system can prioritize and reuse the code-level component with the highest execution efficiency and lowest computing power overhead when planning target tasks, thus achieving an adaptive optimal solution for the allocation of system computing power resources.

[0103] In some embodiments, the method for generating the task processing component may further include: deleting the first execution state component corresponding to the target task from the preset component library.

[0104] Therefore, by deleting the corresponding first execution state component after it is added to the database, the deduplication and seamless iteration of assets within the component library are achieved, avoiding decision confusion caused by the existence of multiple component versions of the same task when the agent is searching.

[0105] In some embodiments, such as Figure 7 As shown, a task processing method based on an intelligent agent is provided, including: step S701, receiving task description information of a target task; step S702, generating task execution planning information through a task processing intelligent agent based on the task description information and various task processing components in a preset component library, wherein the task execution planning information is used to indicate at least one subtask to be executed to complete the target task, the task processing components corresponding to each subtask, and the execution dependencies between each subtask; and step S703, according to the task execution planning information, executing each subtask in the at least one subtask by calling the task processing component corresponding to the subtask to obtain the execution result of the target task, wherein the preset component library includes at least one task processing component generated based on the above-mentioned task processing component generation method.

[0106] Therefore, by generating task execution planning information based on a preset component library and calling the corresponding task processing components to complete the task, the task processing agent can improve the task execution efficiency and reduce the inference cost of the agent by calling the pre-encapsulated task processing components corresponding to complex business flows.

[0107] In some embodiments, executing a subtask by invoking a task processing component corresponding to the subtask for each of the at least one subtask may include: for each of the at least one subtask, performing the following operations: creating a first-level sub-agent corresponding to the subtask; and invoking a task processing component corresponding to the subtask through the first-level sub-agent to execute the subtask.

[0108] Therefore, by creating independent first-level sub-agents for each subtask to call components, logical decoupling and sub-scheduling of complex tasks during execution are achieved. This enables the main agent (task processing agent) to execute tasks in a hierarchical multi-agent collaborative architecture, effectively avoiding context overload or logical illusion when a single agent is dealing with a lengthy call chain, and further improving the stability and accuracy of task execution.

[0109] In some embodiments, the task processing components in the preset component library can be divided into a first execution state component and a second execution state component. The first execution state component may include a first description file, which includes first instruction text described in natural language to indicate the calling interface information and execution logic of the first execution state component. The execution logic of the first execution state component indicates the calling flow and parameter passing relationship of each underlying task processing component called in the first execution state component. The second execution state component may include a second description file and a target script file. The second description file includes third instruction text described in natural language to indicate the calling interface information of the second execution state component and the calling operation for the target script file.

[0110] Therefore, by clearly dividing the pre-defined component library into first-state components that depend on natural language execution logic and second-state components that depend on the target script, the system can balance the flexibility of task logic with the stability of underlying execution.

[0111] In some embodiments, such as Figure 8 As shown, executing a subtask by calling the task processing component corresponding to the subtask through a first-level sub-agent may include: Step S801, responding to the task processing component corresponding to the subtask being a first execution state component, parsing a first description file through the first-level sub-agent; Step S802, obtaining the input data corresponding to the subtask, and inputting the input data into the first execution state component based on the call interface information corresponding to the first execution state component obtained through parsing; Step S803, scheduling each underlying task processing component sequentially through the first-level sub-agent according to the call flow and parameter passing relationship of each underlying task processing component indicated in the execution logic obtained through parsing, and obtaining the execution result of each underlying task processing component based on the input data; Step S804, extracting the corresponding output data from the execution result of each underlying task processing component based on the call interface information corresponding to the first execution state component, and using it as the execution result of the first execution state component; and Step S805, determining the execution result of the first execution state component as the execution result of the subtask.

[0112] Therefore, by parsing the first description file through a first-level sub-agent to schedule various underlying task processing components, and strictly extracting and weighting the output data based on the call interface information, robust calls to the first execution state components are achieved during the execution phase. The task flow is dynamically advanced by utilizing the natural language understanding capabilities of the large model, while the structured interface information is used to constrain the input and output boundaries of the data, ensuring the accuracy of task execution in complex scheduling scenarios.

[0113] In some embodiments, the first description file may further include a second instruction text, which may be used to instruct the first-level sub-agent to create a second-level sub-agent corresponding to the underlying task processing component before calling each underlying task processing component, so as to call the underlying task processing component through the second-level sub-agent.

[0114] Thus, by instructing the first-level sub-agent to create a second-level sub-agent to call the underlying task processing components, the logic decoupling and sub-scheduling of complex tasks during execution are realized. This enables the main agent (task processing agent) to execute tasks in a hierarchical multi-agent collaborative architecture, effectively avoiding context overload or logic illusion when a single agent is dealing with a lengthy call chain, and further improving the stability and accuracy of task execution.

[0115] In some embodiments, such as Figure 9 As shown, executing a subtask by calling the task processing component corresponding to the subtask through a first-level sub-agent may include: Step S901, responding to the task processing component corresponding to the subtask being a second execution state component, parsing the second description file through the first-level sub-agent; Step S902, obtaining the input data corresponding to the subtask, and inputting the input data into the second execution state component based on the call interface information corresponding to the second execution state component obtained through parsing; Step S903, executing the commands in the target script file through the first-level sub-agent to process the input data and obtain the execution result of the target script file; Step S904, extracting the corresponding output data from the execution result of the target script file based on the call interface information corresponding to the second execution state component, and using it as the execution result of the second execution state component; and Step S905, determining the execution result of the second execution state component as the execution result of the subtask.

[0116] Therefore, by parsing the second description file to obtain the call interface information and directly processing the data by executing the target script file, the output results are extracted based on the call interface information. This achieves an automatic transformation of the component form from natural language scheduling to direct execution based on code logic. While maintaining seamless compatibility with external interfaces, the internal cumbersome node scheduling is directly controlled by the script code, further reducing the inference cost of the agent, improving the execution efficiency of the agent, and enhancing the stability and accuracy of task execution.

[0117] In some embodiments, the target script file may include a calling command for the execution script file corresponding to each of the multiple underlying task processing components and a child process creation command. The child process creation command can be used to create a new operating system child process to execute the command in the execution script file corresponding to the underlying task processing component.

[0118] Therefore, by using the calling commands and subprocess creation commands in the target script file to create new operating system subprocesses and execute code, process-level isolation between various underlying task processing components is achieved at the code execution level. This effectively avoids dependency conflicts or memory leaks when different components run in the same memory space, and improves the security and concurrency stability of the entire task flow execution.

[0119] Understandably, the above task processing methods have been described in detail above and will not be repeated here.

[0120] Figure 10 A flowchart of a target task processing component generated according to an exemplary embodiment of the present disclosure is shown.

[0121] In some exemplary embodiments, such as Figure 10 As shown, a method for generating a target task processing component is provided, which may specifically include: The system receives task description information. Based on this description and task processing components in a pre-defined component library, the task processing agent generates task execution planning information (indicating at least one subtask required to complete the target task, the corresponding task processing components for each subtask, and the execution dependencies between subtasks). According to this execution planning information, the system sequentially calls the corresponding task processing component's API to execute each subtask. When calling a task processing component, the system can preferentially choose to call its second execution state component; if no second execution state component exists, its corresponding first execution state component is called. During the execution of the task, the system records relevant information about the task execution trajectory and persistently saves the task execution information to the historical task execution record.

[0122] The evolutionary engine in the system periodically reads the aforementioned historical task execution records and extracts patterns from the task execution information to obtain the corresponding abstract execution patterns (i.e., execution trajectory information). Then, the evolutionary engine performs frequency analysis to count the number of times target tasks with the same execution trajectory information have been executed in history. Finally, based on the results of the frequency analysis, different component generation processes are triggered: when the number of times the target task is executed is greater than a first preset threshold (i.e., frequency > X in the figure) and the preset component library does not contain a task processing component corresponding to the target task, a first execution state component corresponding to the target task is generated and added to the library where the first execution state component is located; when the number of times the target task is executed is greater than a higher second preset threshold (i.e., frequency > Y in the figure) and a corresponding first execution state component already exists, a second execution state component corresponding to the target task is generated and added to the library where the second execution state component is located.

[0123] In some embodiments, such as Figure 11As shown, a task processing component generation device 1100 is provided. The device 1100 includes: a first acquisition unit 1110, configured to acquire a target task whose execution count meets a preset condition from multiple historical tasks, wherein the execution count is obtained by statistically analyzing historical tasks with the same execution trajectory; and a first generation unit 1120, configured to, in response to acquiring the target task, generate a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task. The execution trajectory information includes component interface information of each task processing component used to execute the target task and execution dependencies between each task processing component. The target task processing component includes a component description file for indicating the call interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The call interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependencies. The execution logic indicates the call flow of each task processing component based on the execution dependencies and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

[0124] The operations performed by units 1110 and 1120 in the task processing component generation device 1100 and the technical effects they can achieve are similar to steps S201 and S202 in the task processing component generation method and will not be described again here.

[0125] In some embodiments, the first generation unit may be further configured to: in response to determining that there is no task processing component corresponding to the target task in the preset component library, generate a first execution-state component corresponding to the target task, the first execution-state component including a first description file, the generation of the first description file including: sorting out the component interface information of each task processing component used to execute the target task based on execution dependencies to obtain call interface information; and generating the first description file based on the call interface information and execution trajectory information, wherein the first description file includes a first instruction text described in natural language for indicating the call interface information and execution logic; and determining the first description file as a component description file, and determining the first execution-state component as the target task processing component corresponding to the target task.

[0126] In some embodiments, the first description file may further include a second instruction text, which is used to instruct the creation of a sub-agent corresponding to the task processing component before invoking the respective task processing component for executing the target task, so as to invoke the task processing component through the sub-agent.

[0127] In some embodiments, the apparatus for generating the task processing component described above may further include: The first adding unit is configured to add the first execution state component as the target task processing component corresponding to the target task to the preset component library.

[0128] In some embodiments, the aforementioned preset conditions may include the number of times the target task is executed being greater than a first preset threshold. The first generation unit may be further configured to: in response to determining that the number of executions is greater than a second preset threshold and that the task processing component corresponding to the target task in the preset component library is a first execution-state component, generate a second execution-state component corresponding to the target task. The second preset threshold is greater than the first preset threshold. The second execution-state component includes a second description file and a target script file. The generation of the second description file and the target script file may include: parsing the first description file of the first execution-state component to extract call interface information; obtaining the respective execution script files of each task processing component used to execute the target task; generating a target script file based on the execution trajectory information and the respective execution script files of each task processing component; generating a second description file based on the call interface information and the target script file, wherein the second description file includes a third instruction text described in natural language for indicating the call interface information and the call operation for the target script file; and determining the second description file and the target script file as a component description file, and determining the second execution-state component as the target task processing component corresponding to the target task.

[0129] In some embodiments, generating a target script file based on execution trajectory information and the respective execution script files of each task processing component may include: determining the parameter sources of each task processing component used to execute the target task based on execution dependencies, wherein the parameter sources include the output of the previously executed task processing component or the global input of the target task; converting the variables corresponding to the parameter sources of each task processing component into command-line parameters for calling the corresponding execution script file of the task processing component based on the component interface information of each task processing component; and filling the calling paths and command-line parameters of the execution script files corresponding to each task processing component into a preset code template according to the calling order indicated by the execution dependencies to generate the target script file, wherein the target script file passes the data from the parameter sources to the corresponding execution script file through command-line parameters when it is executed.

[0130] In some embodiments, the preset code template may also include subprocess creation commands corresponding to each task processing component used to execute the target task. The subprocess creation commands can be used to create new operating system subprocesses to execute commands in the execution script file corresponding to the task processing component.

[0131] In some embodiments, the above-mentioned task processing component generation apparatus may further include: a second adding unit, configured to add the second execution state component as the target task processing component corresponding to the target task to a preset component library.

[0132] In some embodiments, the above-described task processing component generation apparatus may further include: a deletion unit configured to delete the first execution state component corresponding to the target task in a preset component library.

[0133] In some embodiments, such as Figure 12 As shown, a task processing device 1200 based on an intelligent agent is provided. The device 1200 includes: a first receiving unit 1210 configured to receive task description information of a target task; a first generating unit 1220 configured to generate task execution planning information through a task processing intelligent agent based on the task description information and various task processing components in a preset component library, wherein the task execution planning information is used to indicate at least one subtask to be executed to complete the target task, the task processing components corresponding to each subtask, and the execution dependencies between the subtasks; and a first execution unit 1230 configured to execute each subtask in the at least one subtask by calling the task processing component corresponding to the subtask according to the task execution planning information, so as to obtain the execution result of the target task, wherein the preset component library includes at least one task processing component generated based on the above-mentioned task processing component generation method.

[0134] The operations performed by units 1210 to 1230 in the above-mentioned agent-based task processing device 1200 and the technical effects they can achieve are similar to steps S701 to S703 in the above-mentioned agent-based task processing method, and will not be described again here.

[0135] In some embodiments, the first execution unit may be further configured to: for each subtask in at least one subtask, perform the following operations: create a first-level sub-agent corresponding to the subtask; and invoke a task processing component corresponding to the subtask through the first-level sub-agent to execute the subtask.

[0136] In some embodiments, the task processing components in the preset component library can be divided into a first execution state component and a second execution state component. The first execution state component includes a first description file, which includes first instruction text described in natural language to indicate the calling interface information and execution logic of the first execution state component. The execution logic of the first execution state component indicates the calling flow and parameter passing relationship of each underlying task processing component called in the first execution state component. The second execution state component includes a second description file and a target script file. The second description file includes third instruction text described in natural language to indicate the calling interface information and calling operations for the target script file.

[0137] In some embodiments, executing a subtask by invoking a task processing component corresponding to the subtask through a first-level sub-agent may include: responding to the task processing component corresponding to the subtask being a first execution state component, parsing a first description file through the first-level sub-agent; obtaining input data corresponding to the subtask, and inputting the input data into the first execution state component based on the parsed call interface information corresponding to the first execution state component; sequentially scheduling each underlying task processing component according to the call flow and parameter passing relationship of each underlying task processing component indicated in the parsed execution logic, and obtaining the execution results of each underlying task processing component based on the input data; extracting corresponding output data from the execution results of each underlying task processing component based on the call interface information corresponding to the first execution state component, and using it as the execution result of the first execution state component; and determining the execution result of the first execution state component as the execution result of the subtask.

[0138] In some embodiments, the first description file may further include a second instruction text, which may be used to instruct the first-level sub-agent to create a second-level sub-agent corresponding to the underlying task processing component before calling each underlying task processing component, so as to call the underlying task processing component through the second-level sub-agent.

[0139] In some embodiments, executing a subtask by invoking a task processing component corresponding to the subtask through a first-level sub-agent may include: responding to the task processing component corresponding to the subtask being a second execution state component, parsing a second description file through the first-level sub-agent; obtaining input data corresponding to the subtask, and inputting the input data into the second execution state component based on the parsed call interface information corresponding to the second execution state component; executing commands in a target script file through the first-level sub-agent to process the input data and obtain the execution result of the target script file; extracting corresponding output data from the execution result of the target script file based on the call interface information corresponding to the second execution state component, and using this as the execution result of the second execution state component; and determining the execution result of the second execution state component as the execution result of the subtask.

[0140] In some embodiments, the target script file may include a calling command for the execution script file corresponding to each of the multiple underlying task processing components and a child process creation command. The child process creation command can be used to create a new operating system child process to execute the command in the execution script file corresponding to the underlying task processing component.

[0141] The collection, storage, use, processing, transmission, provision, and disclosure of any type of information, such as user personal information, in this technical solution comply with relevant laws and regulations and do not violate public order and good morals.

[0142] According to embodiments of this disclosure, an electronic device, a readable storage medium, and a computer program product are also provided.

[0143] refer to Figure 13 The present invention describes a structural block diagram of an electronic device 1300 that can serve as a server or client of the present disclosure, which is an example of a hardware device that can be applied to various aspects of the present disclosure. The electronic device is intended to represent various forms of digital electronic computer devices, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0144] like Figure 13As shown, the electronic device 1300 includes a computing unit 1301, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 1302 or a computer program loaded from a storage unit 1308 into a random access memory (RAM) 1303. The RAM 1303 may also store various programs and data required for the operation of the electronic device 1300. The computing unit 1301, ROM 1302, and RAM 1303 are interconnected via a bus 1304. An input / output (I / O) interface 1305 is also connected to the bus 1304.

[0145] Multiple components in electronic device 1300 are connected to I / O interface 1305, including: input unit 1306, output unit 1307, storage unit 1308, and communication unit 1309. Input unit 1306 can be any type of device capable of inputting information to electronic device 1300. Input unit 1306 can receive input digital or character information and generate key signal inputs related to user settings and / or function control of the electronic device, and may include, but is not limited to, a mouse, keyboard, touchscreen, trackpad, trackball, joystick, microphone, and / or remote control. Output unit 1307 can be any type of device capable of presenting information, and may include, but is not limited to, a monitor, speaker, video / audio output terminal, vibrator, and / or printer. Storage unit 1308 may include, but is not limited to, a hard disk and an optical disk. The communication unit 1309 allows the electronic device 1300 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks, and may include, but is not limited to, modems, network cards, infrared communication devices, wireless communication transceivers and / or chipsets, such as Bluetooth devices, 802.11 devices, WiFi devices, WiMax devices, cellular communication devices and / or the like.

[0146] The computing unit 1301 can be various general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 1301 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 1301 performs the various methods and processes described above, such as the methods for generating the task processing components described above or the agent-based task processing methods. For example, in some embodiments, the methods for generating the task processing components described above or the agent-based task processing methods described above can be implemented as computer software programs, which are tangibly contained in a machine-readable medium, such as storage unit 1308. In some embodiments, part or all of the computer program can be loaded and / or installed on the electronic device 1300 via ROM 1302 and / or communication unit 1309. When the computer program is loaded into RAM 1303 and executed by the computing unit 1301, one or more steps of the methods for generating the task processing components described above or the agent-based task processing methods can be performed. Alternatively, in other embodiments, the computing unit 1301 may be configured by any other suitable means (e.g., by means of firmware) to perform the above-described task processing component generation method or agent-based task processing method.

[0147] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), complex programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0148] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0149] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on 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 fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0150] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0151] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0152] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0153] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be performed in parallel, sequentially, or in a different order, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0154] While embodiments or examples of this disclosure have been described with reference to the accompanying drawings, it should be understood that the methods, systems, and devices described above are merely exemplary embodiments or examples, and the scope of the invention is not limited by these embodiments or examples, but only by the granted claims and their equivalents. Various elements in the embodiments or examples may be omitted or replaced by their equivalents. Furthermore, the steps may be performed in a different order than that described in this disclosure. Further, various elements in the embodiments or examples may be combined in various ways. Importantly, as the technology evolves, many elements described herein can be replaced by equivalents that appear after this disclosure.

Claims

1. A method for generating a task processing component, the method comprising: Among multiple historical tasks, the target task whose execution count meets the preset conditions is obtained. The execution count is obtained by statistically analyzing historical tasks with the same execution trajectory information. as well as In response to obtaining the target task, a target task processing component is generated based on the execution trajectory information corresponding to the target task. The execution trajectory information includes component interface information for each task processing component used to execute the target task and the execution dependencies between the task processing components. The target task processing component includes a component description file indicating the calling interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The call interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependency relationship. The execution logic indicates the call flow of each task processing component based on the execution dependency relationship, and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

2. The method of claim 1, wherein, The step of generating a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task in response to obtaining the target task includes: In response to determining that no task processing component corresponding to the target task exists in the preset component library, a first execution-state component corresponding to the target task is generated. The first execution-state component includes a first description file, and the generation of the first description file includes: Based on the execution dependencies, the component interface information of each task processing component used to execute the target task is sorted out to obtain the call interface information; and Based on the API call information and the execution trajectory information, a first description file is generated, wherein the first description file includes first instruction text described in natural language for indicating the API call information and the execution logic; and The first description file is determined as the component description file, and the first execution-state component is determined as the target task processing component corresponding to the target task.

3. The method of claim 2, wherein, The first description file also includes a second instruction text, which is used to instruct that before calling each task processing component for executing the target task, a sub-agent corresponding to the task processing component is created so that the task processing component can be called through the sub-agent.

4. The method according to claim 2 or 3, further comprising: The first execution state component is added to the preset component library as the target task processing component corresponding to the target task.

5. The method of claim 4, wherein, The preset conditions include the number of times the target task is executed being greater than a first preset threshold. The step of generating a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task, in response to obtaining the target task, includes: In response to determining that the number of executions is greater than a second preset threshold and that the task processing component corresponding to the target task included in the preset component library is the first execution state component, a second execution state component corresponding to the target task is generated. The second preset threshold is greater than the first preset threshold. The second execution state component includes a second description file and a target script file. The generation of the second description file and the target script file includes: Parse the first description file of the first execution-state component to extract the call interface information; Obtain the respective execution script files for each task processing component used to execute the target task; Based on the execution trajectory information and the execution script files of each task processing component, the target script file is generated; Based on the API call information and the target script file, a second description file is generated, wherein the second description file includes third instruction text described in natural language for indicating the API call information and the call operation for the target script file; and The second description file and the target script file are identified as the component description file, and the second execution-state component is identified as the target task processing component corresponding to the target task.

6. The method of claim 5, wherein, The process of generating the target script file based on the execution trajectory information and the respective execution script files of each task processing component includes: Based on the execution dependencies, the parameter sources for each task processing component used to execute the target task are determined, and the parameter sources include the output of the previously executed task processing component or the global input of the target task; Based on the component interface information of each task processing component, the variables corresponding to the parameter sources of that task processing component are converted into command-line parameters for calling the corresponding execution script file of that task processing component; and The call paths of the execution script files corresponding to each task processing component and the command-line parameters are filled into the preset code template according to the calling order indicated by the execution dependency relationship to generate the target script file. When the target script file is executed, it passes the data from the parameter source to the corresponding execution script file through the command-line parameters.

7. The method of claim 6, wherein, The preset code template also includes subprocess creation commands corresponding to each task processing component used to execute the target task. The subprocess creation commands are used to create new operating system subprocesses to execute commands in the execution script file corresponding to the task processing component.

8. The method according to any one of claims 5 to 7, further comprising: The second execution state component is added to the preset component library as the target task processing component corresponding to the target task.

9. The method according to claim 8, further comprising: Delete the first execution state component corresponding to the target task from the preset component library.

10. A task processing method based on an intelligent agent, the method comprising: Receive the task description information for the target task; Based on the task description information and each task processing component in the preset component library, task execution planning information is generated by the task processing agent. The task execution planning information is used to indicate at least one subtask to be executed to complete the target task, the task processing component corresponding to each subtask, and the execution dependency relationship between each subtask. as well as Based on the task execution planning information, for each subtask in the at least one subtask, the corresponding task processing component is invoked to execute the subtask, thereby obtaining the execution result of the target task. The preset component library includes at least one task processing component generated based on the method described in any one of claims 1 to 9.

11. The method of claim 10, wherein, The step of executing each subtask in the at least one subtask by calling the task processing component corresponding to that subtask includes: For each subtask in the at least one subtask, perform the following operations: Create a first-level sub-agent corresponding to the sub-task; and The first-level sub-agent invokes the task processing component corresponding to the sub-task to execute the sub-task.

12. The method of claim 11, wherein, The task processing components in the preset component library are divided into a first execution state component and a second execution state component, wherein... The first execution-state component includes a first description file, which includes first instruction text in natural language describing the calling interface information and execution logic of the first execution-state component. The execution logic of the first execution-state component indicates the calling flow and parameter passing relationships of each underlying task processing component called by the first execution-state component; and wherein, The second execution-state component includes a second description file and a target script file. The second description file includes a third instruction text, described in natural language, for indicating the calling interface information of the second execution-state component and the calling operation for the target script file.

13. The method of claim 12, wherein, The step of invoking the task processing component corresponding to the sub-task through the first-level sub-agent to execute the sub-task includes: In response to the task processing component corresponding to the subtask being the first execution state component, the first description file is parsed through the first-level sub-intelligent agent; Obtain the input data corresponding to the subtask, and input the input data into the first execution state component based on the call interface information corresponding to the first execution state component obtained through parsing; According to the calling flow and parameter passing relationship of each underlying task processing component indicated in the execution logic obtained by parsing, the first-level sub-agent sequentially schedules each underlying task processing component to obtain the execution result of each underlying task processing component based on the input data. Based on the call interface information corresponding to the first execution state component, the corresponding output data is extracted from the execution results of each underlying task processing component and used as the execution result of the first execution state component; and The execution result of the first execution state component is determined as the execution result of the subtask.

14. The method of claim 13, wherein, The first description file also includes a second instruction text, which is used to instruct the first-level sub-agent to create a second-level sub-agent corresponding to each underlying task processing component before calling each underlying task processing component, so as to call the underlying task processing component through the second-level sub-agent.

15. The method of any one of claims 12 to 14, wherein, The step of invoking the task processing component corresponding to the sub-task through the first-level sub-agent to execute the sub-task includes: In response to the task processing component corresponding to the subtask being the second execution state component, the second description file is parsed through the first-level sub-intelligent agent; Obtain the input data corresponding to the subtask, and input the input data into the second execution state component based on the call interface information corresponding to the second execution state component obtained through parsing; The first-level sub-intelligent agent executes the commands in the target script file and processes the input data to obtain the execution result of the target script file. Based on the call interface information corresponding to the second execution state component, the corresponding output data is extracted from the execution result of the target script file and used as the execution result of the second execution state component; and The execution result of the second execution state component is determined as the execution result of the subtask.

16. The method of claim 15, wherein, The target script file includes a call command for the execution script file corresponding to each of the multiple underlying task processing components, as well as a subprocess creation command. The subprocess creation command is used to create a new operating system subprocess to execute the commands in the execution script file corresponding to the underlying task processing component.

17. An apparatus for generating a task processing component, the apparatus comprising: The first acquisition unit is configured to acquire target tasks whose execution count meets preset conditions from multiple historical tasks, wherein the execution count is obtained by statistically analyzing historical tasks with the same execution trajectory. as well as The first generation unit is configured to, in response to obtaining the target task, generate a target task processing component corresponding to the target task based on the execution trajectory information corresponding to the target task. The execution trajectory information includes component interface information for each task processing component used to execute the target task and execution dependencies between the task processing components. The target task processing component includes a component description file indicating the calling interface information and execution logic of the target task processing component. The target task processing component is invoked based on the parsing of the component description file by the task processing agent. The call interface information is obtained by sorting out the component interface information of each task processing component according to the execution dependency relationship. The execution logic indicates the call flow of each task processing component based on the execution dependency relationship, and indicates the parameter passing relationship between each task processing component based on the component interface information of each task processing component.

18. A task processing device based on an intelligent agent, the device comprising: The first receiving unit is configured to receive the task description information of the target task; The first generation unit is configured to generate task execution planning information through a task processing agent based on the task description information and various task processing components in the preset component library. The task execution planning information is used to indicate at least one subtask to be executed to complete the target task, the task processing components corresponding to each subtask, and the execution dependencies between each subtask. as well as The first execution unit is configured to, based on the task execution planning information, execute each subtask in the at least one subtask by calling the task processing component corresponding to that subtask, in order to obtain the execution result of the target task, wherein... The preset component library includes at least one task processing component generated based on the method described in any one of claims 1 to 9.

19. An electronic device comprising: At least one processor; as well as A memory that is communicatively connected to the at least one processor; in The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-16.

20. A non-transitory computer readable storage medium having stored thereon computer instructions, wherein, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-16.

21. A computer program product comprising a computer program, wherein, When the computer program is executed by a processor, it implements the method of any one of claims 1-16.

Images