An agent skill-oriented visual debugging method
By building a simulated terminal device in a sandbox debugging instance to receive user commands and verify the operational status of the intelligent agent's skills, the problem of unreliable debugging results in the existing technology is solved, and a visual debugging effect consistent with the online version is achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- SHENZHEN RABBIT PREMISE TECH CO LTD
- Filing Date
- 2026-05-20
- Publication Date
- 2026-07-31
AI Technical Summary
Existing intelligent agent skill debugging schemes cannot accurately reproduce the operation process, resulting in significant deviations between debugging results and actual online execution results, making them unreliable as a basis for online verification.
Construct a sandbox debugging instance to simulate a terminal device, and receive debugging commands input by the user through the simulated terminal device to verify the execution status of the running instance, thereby realizing the visual debugging of the agent's skills.
Ensure that the debugging process is consistent with the online usage, isolate external environmental factors from interference, and improve the reliability of the debugging results.
Smart Images
Figure CN122220205B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of intelligent agent skills, and more particularly to a visual debugging method for intelligent agent skills. Background Technology
[0002] With the rapid development of artificial intelligence technology, intelligent agent skills are widely used in enterprise-level business scenarios. Before deployment, intelligent agent skills typically need to be verified through debugging to ensure the rationality of process logic, parameter passing, interactive responses, and exception handling, so as to ensure stable operation after deployment.
[0003] Currently, existing intelligent agent skill debugging solutions generally adopt an interface call-based debugging approach. Specifically, a manual call request is initiated for a single interface of the intelligent agent skill. Then, the interface is debugged by obtaining the call status returned by the interface, the interface execution result, and the interface execution log information.
[0004] However, debugging based on API calls cannot reproduce the actual operational chain of node dependencies, parameter flow, and data context transmission during the actual operation of intelligent agent skills. This results in a significant discrepancy between the debugging results and the actual online execution results, making it difficult to serve as a reliable basis for the online verification of intelligent agent skills. Summary of the Invention
[0005] This application provides a visualization debugging method for intelligent agent skills, aiming to solve the technical problem that the existing technology cannot truly reproduce the operation scenario of intelligent agent skills, resulting in low reliability of debugging results.
[0006] In a first aspect, embodiments of this application provide a visual debugging method for intelligent agent skills, comprising: In response to the user selecting the target simulation device type in the debug interaction tab area and triggering the start debug operation, a preset debug pre-verification is performed on the target intelligent agent's skills; If the result of the preset debugging pre-verification is passed, then a sandbox debugging instance is constructed; In the sandbox debugging instance, a debugging environment for the target agent skill is constructed, and the debugging environment includes a running instance of the target agent skill; Construct a simulation terminal device based on the target simulation device type; The system receives debugging commands input by the user on the interface of the simulated terminal device and forwards the debugging commands to the running instance. The debugging commands are used to verify the execution status of the running instance.
[0007] Optionally, the pre-debugging verification of the target agent's skills includes: Obtain the full lifecycle state and configuration information of the target intelligent agent's skills; Perform an integrity check on the configuration information; If the full lifecycle status is a draft status, and the integrity verification result is passed, then the result of the preset debugging pre-verification is determined to be passed. If the full lifecycle status is a non-draft status, or if the integrity verification result is a failure, then the result of the preset debugging pre-verification is determined to be a failure.
[0008] Optionally, the step of constructing the debugging environment for the target agent's skill in the sandbox debugging instance includes: Obtain the configuration information of the target agent's skills; The target agent skill is deployed in the sandbox debugging instance according to the configuration information to form a running instance of the target agent skill.
[0009] Optionally, the debugging environment further includes a test association service for the target agent's skills, and the method further includes: Deploy the associated services of the target agent's skills in the sandbox debugging instance to form the test associated services; Synchronize the associated service data of the target agent's skills in the production environment to the test associated service.
[0010] Optionally, before building the debugging environment for the target agent's skill in the sandbox debugging instance, the method further includes: Set the configuration information of the target agent's skills to read-only.
[0011] Optionally, the method further includes: Obtain the execution status information of the running instance; The execution status information is displayed through a visual interface.
[0012] Optionally, the target intelligent agent skill includes multiple functional nodes, the execution state information includes the execution state information of each of the multiple functional nodes, and the step of displaying the execution state information through a visual interface includes: Multiple interconnected visualization cards are constructed according to the execution order of the multiple functional nodes, and the multiple visualization cards correspond one-to-one with the multiple functional nodes; Each of the multiple visualization cards displays the execution status information of the functional node corresponding to that visualization card.
[0013] Optionally, the plurality of functional nodes include target functional nodes, and the display of the execution status information of the functional node corresponding to the visualization card on each of the plurality of visualization cards includes: If the running instance reaches the target function node, a first identifier is displayed on the visualization card corresponding to the target function node. The first identifier is used to indicate that the target function node is in the execution state. If the running instance executes successfully on the target functional node, a second identifier is displayed on the visualization card corresponding to the target functional node. The second identifier is used to indicate that the target functional node is in a successful execution state. If the running instance fails to execute on the target functional node, a third identifier is displayed on the visualization card corresponding to the target functional node. The third identifier is used to indicate that the target functional node is in an execution failure state. If the running instance does not reach the target function node, a fourth identifier is displayed on the visualization card corresponding to the target function node. The fourth identifier is used to indicate that the target function node is in an inactive state.
[0014] Optionally, the method further includes: After the running instance finishes running, the sandbox debugging instance is destroyed.
[0015] Optionally, the method further includes: After the running instance finishes running, the configuration information of the target agent's skills is set to a read-write state.
[0016] Secondly, embodiments of this application also provide a visualization debugging device for intelligent agent skills, which includes a unit for performing the above-described method.
[0017] Thirdly, embodiments of this application also provide a computer device, which includes a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the above-described method.
[0018] Fourthly, embodiments of this application also provide a computer-readable storage medium storing a computer program that, when executed by a processor, can implement the above-described method.
[0019] This application provides a visual debugging method for intelligent agent skills. The method includes: responding to a user selecting a target simulated device type in the debugging interaction tab area and triggering a debugging start operation, performing a preset debugging pre-verification on the target intelligent agent skill; if the preset debugging pre-verification passes, constructing a sandbox debugging instance; constructing a debugging environment for the target intelligent agent skill in the sandbox debugging instance, the debugging environment including a running instance of the target intelligent agent skill; constructing a simulated terminal device based on the target simulated device type; receiving a debugging command input by the user on the interface of the simulated terminal device, and forwarding the debugging command to the running instance, the debugging command being used to verify the execution status of the running instance. Therefore, this application first responds to a user selecting a target simulated device type in the debugging interaction tab area and triggering a debugging start operation, performing a preset debugging pre-verification on the target intelligent agent skill. Next, if the preset debugging pre-verification passes, a sandbox debugging instance is constructed. Furthermore, a debugging environment for the target intelligent agent skill is constructed in the sandbox debugging instance. The debugging environment includes a running instance of the target intelligent agent skill. Subsequently, a simulated terminal device is constructed based on the target simulated device type. Finally, the debugging commands input by the user are received on the interface of the simulated terminal device, and then forwarded to the running instance. These debugging commands are used to verify the execution status of the running instance. Therefore, the technical solution of this application constructs an independent sandbox simulation debugging environment and a simulated terminal device corresponding to the target intelligent agent skill. By interacting with the user on the simulated terminal device and receiving the user's input debugging commands in real time, it achieves visualized debugging of the target intelligent agent skill. This mechanism, on the one hand, can realistically reproduce the actual operating scenario of the target intelligent agent skill, ensuring that the debugging process is consistent with the actual online usage; on the other hand, it can effectively isolate the interference of external environmental factors, avoiding the impact of debugging operations on online business, thereby effectively improving the reliability of the debugging results of the target intelligent agent skill. Attached Figure Description
[0020] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.
[0021] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0022] One or more embodiments are illustrated by way of example with reference numerals in the accompanying drawings. These illustrations do not constitute a limitation on the embodiments. Elements with the same reference numerals in the drawings are denoted as similar elements. Unless otherwise stated, the figures in the drawings are not to be limited by scale.
[0023] Figure 1a A flowchart illustrating a visual debugging method for intelligent agent skills provided in an embodiment of this application; Figure 1b A target intelligent agent skill debugging interface provided in the embodiments of this application; Figure 2 A schematic block diagram of a visualization debugging device for intelligent agent skills provided in an embodiment of this application; Figure 3 A computer device provided in an embodiment of this application. Detailed Implementation
[0024] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0025] The following disclosure provides numerous different embodiments or examples for implementing various structures of this application. To simplify the disclosure, specific examples of components and arrangements are described below. These are merely examples and are not intended to limit the scope of this application. Furthermore, reference numerals and / or letters may be repeated in different examples. Such repetition is for simplification and clarity and does not in itself indicate a relationship between the various embodiments and / or arrangements discussed.
[0026] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.
[0027] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the scope of the application. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.
[0028] It should also be further understood that the term “and / or” as used in this application specification and the appended claims means any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.
[0029] As used in this specification and the appended claims, the term "if" may be interpreted, depending on the context, as "when," "once," "in response to determination," or "in response to detection." Similarly, the phrase "if determined" or "if [described condition or event] is detected" may be interpreted, depending on the context, as "once determined," "in response to determination," "once [described condition or event] is detected," or "in response to detection of [described condition or event]."
[0030] To address the technical problem that existing technologies cannot realistically reproduce the operational scenarios of intelligent agent skills, resulting in low reliability of debugging results, this application provides a visual debugging device for intelligent agent skills, which can realistically reproduce the operational scenarios of intelligent agent skills and improve the reliability of debugging results.
[0031] Figure 1a This is a flowchart illustrating a visual debugging method for intelligent agent skills provided in an embodiment of this application. Figure 1b This application provides a target intelligent agent skill debugging interface. In one embodiment, the method includes: S101-S105.
[0032] S101. In response to the user selecting the target simulation device type in the debugging interaction tab area and triggering the start debugging operation, perform preset debugging pre-verification on the target intelligent agent's skills.
[0033] Specifically, the debugging interaction tab area is located in the debugging panel on the side of the target agent's skill configuration page. Preferably, the debugging interaction tab area is located in the debugging TAB panel on the right side of the target agent's skill configuration page. The debugging interaction tab area has a "Debug" button, allowing the user to initiate the debugging operation. Users can complete the skill configuration and debugging of the target agent's skills without switching any pages. For example, see... Figure 1b The target intelligent agent skill is the department registration skill. Figure 1b On the left is the API interface information required for the department's registration function. Figure 1b The middle section contains information about each node of the department's registration process. Figure 1b On the right side is the node configuration information and debugging panel for the department registration skill. Users can select a target simulation device type to enter debugging mode.
[0034] The target simulated device types include, but are not limited to, mobile phones, tablets, smartwatches, smart TVs, and smart screens.
[0035] Furthermore, the preset debugging pre-verification will be described in detail in the later embodiments of this application. It will not be repeated here.
[0036] S102. If the result of the preset pre-debugging verification is passed, then construct a sandbox debugging instance.
[0037] To avoid the impact of the debugging process on the actual production environment of the target agent's skills, this application embodiment constructs a sandbox debugging environment completely isolated from the production environment, namely, a sandbox debugging instance. Specifically, this application embodiment uses the Kubernetes technology framework to achieve isolation between the runtime space and the network space. This application embodiment allocates an independent namespace and network policy to each debugging sandbox instance. Network access control for the debugging sandbox instance is implemented through a whitelist in the network policy, preventing the debugging sandbox instance from accessing the production environment subnet routes, thus fundamentally avoiding unauthorized access control at the network layer.
[0038] S103. Construct a debugging environment for the target agent's skills in a sandbox debugging instance.
[0039] The debugging environment includes running instances of the target agent's skills.
[0040] Specifically, in this embodiment of the application, a running instance of the target agent skill is deployed in a sandbox debugging instance.
[0041] S104. Construct a simulation terminal device based on the target simulation device type.
[0042] For example, if the target simulated device type is a mobile phone, a virtual machine terminal device is constructed. This simulated terminal device is provided to the user. The user can use the simulated terminal device to test or use the target intelligent agent's skills.
[0043] It should be noted that the simulated terminal device can reproduce the screen size, interaction method, runtime environment, and card rendering rules of the corresponding device, thereby verifying the interactive display and operational adaptability of the target intelligent agent's skills on different devices.
[0044] S105. Receive debugging commands input by the user on the interface of the simulated terminal device and forward the debugging commands to the running instance.
[0045] Debug commands are used to verify the execution status of a running instance.
[0046] It should be noted that debugging commands include, but are not limited to, user-inputted text commands, user-inputted touch commands, user-inputted swipe commands, and user-inputted voice commands. After receiving the user-inputted debugging command, the simulated terminal device sends the command to the running instance, enabling the running instance to execute the relevant test service functions.
[0047] In addition, users can build dialogue input boxes and card interaction areas in simulated terminal devices that are completely identical to those on the online C-end. Simultaneously, it supports natural language input, multi-turn dialogue responses, and interactive card operations, enabling complete verification of the entire process from user intent recognition, skill matching, workflow execution, parameter extraction, interaction triggering, and exception handling, achieving end-to-end business testing.
[0048] This application provides a visual debugging method for intelligent agent skills. The method includes: responding to a user selecting a target simulated device type in the debugging interaction tab area and triggering a debugging start operation, performing a preset debugging pre-verification on the target intelligent agent skill; if the preset debugging pre-verification passes, constructing a sandbox debugging instance; constructing a debugging environment for the target intelligent agent skill in the sandbox debugging instance, the debugging environment including a running instance of the target intelligent agent skill; constructing a simulated terminal device based on the target simulated device type; receiving a debugging command input by the user on the interface of the simulated terminal device, and forwarding the debugging command to the running instance, the debugging command being used to verify the execution status of the running instance. Therefore, this application first responds to a user selecting a target simulated device type in the debugging interaction tab area and triggering a debugging start operation, performing a preset debugging pre-verification on the target intelligent agent skill. Next, if the preset debugging pre-verification passes, a sandbox debugging instance is constructed. Furthermore, a debugging environment for the target intelligent agent skill is constructed in the sandbox debugging instance. The debugging environment includes a running instance of the target intelligent agent skill. Subsequently, a simulated terminal device is constructed based on the target simulated device type. Finally, the debugging commands input by the user are received on the interface of the simulated terminal device, and then forwarded to the running instance. These debugging commands are used to verify the execution status of the running instance. Therefore, the technical solution of this application constructs an independent sandbox simulation debugging environment and a simulated terminal device corresponding to the target intelligent agent skill. By interacting with the user on the simulated terminal device and receiving the user's input debugging commands in real time, it achieves visualized debugging of the target intelligent agent skill. This mechanism, on the one hand, can realistically reproduce the actual operating scenario of the target intelligent agent skill, ensuring that the debugging process is consistent with the actual online usage; on the other hand, it can effectively isolate the interference of external environmental factors, avoiding the impact of debugging operations on online business, thereby effectively improving the reliability of the debugging results of the target intelligent agent skill.
[0049] In one embodiment, the step of “performing a preset debugging pre-verification of the target agent’s skills” in S101 above specifically includes the following steps: ad.
[0050] a. Obtain the full lifecycle status and configuration information of the target intelligent agent's skills.
[0051] The full lifecycle states of a target agent's skill include: draft, online, in development, and failed development. The draft state indicates the skill is currently being created. The online state indicates the skill has been successfully created and is in use. The in development state indicates the skill configuration has been completed and the skill is being generated. The failed development state indicates the skill generation failed.
[0052] The configuration information is the skill configuration information of the target intelligent agent's skills.
[0053] b. Perform integrity verification on the configuration information.
[0054] Specifically, verify whether the business function nodes in the target intelligent agent's skills are complete, whether the API interface configuration of each business function node is valid, and whether there are any abnormalities in the parameter binding of each API interface.
[0055] c. If the entire lifecycle status is draft, and the integrity check result is passed, then the result of the preset debugging pre-check is determined to be passed.
[0056] d. If the entire lifecycle status is non-draft status, or the integrity verification result is failed, then the result of the preset debugging pre-verification is determined to be failed.
[0057] It should be noted that if the entire lifecycle status is non-draft, or if the integrity check result is failed, the user's debugging operation request needs to be intercepted, and the user needs to complete the corresponding configuration information before the debugging operation can be started.
[0058] In one embodiment, S103 specifically includes the following steps: S1031-S1032.
[0059] S1031. Obtain the configuration information of the target agent's skills.
[0060] S1032. Deploy the target agent skill in the sandbox debugging instance according to the configuration information to form a running instance of the target agent skill.
[0061] It should be noted that, in this embodiment of the application, the latest skill configuration information of the target intelligent agent's skills is loaded to complete the deployment of the target intelligent agent's skills.
[0062] In one embodiment, the debugging environment further includes a test association service for the target agent's skills, and the method further includes: S106-S107.
[0063] S106. Deploy the associated services of the target agent's skills in the sandbox debugging instance to form test associated services.
[0064] Specifically, the associated services include, but are not limited to, the test cluster for the target intelligent agent's skills, the permission system service, the shadow API gateway service, and the database. In this embodiment, the test cluster for the target intelligent agent's skills is integrated into the sandbox debugging instance, synchronizing the execution rules, permission system, and interface proxy forwarding rules of the online environment of the target intelligent agent's skills, replicating the online operational chain 1:1. The configuration, version, and execution rules of each service in the sandbox instance are completely consistent with the online production environment. Simultaneously, the associated services in the sandbox instance handle real user requests online. After the sandbox debugging instance ends, the associated services in the sandbox instance are destroyed along with the sandbox instance.
[0065] Furthermore, this embodiment employs a dual isolation scheme of shadow library + data anonymization. A read-only shadow copy of the online production library is created for each debugging sandbox. This shadow copy only synchronizes interface metadata and business rule configurations, not sensitive data of real online users. Moreover, business data generated during debugging is written to an independent sandbox temporary library. This temporary library is automatically destroyed after debugging, ensuring no impact on online production data. Additionally, the sandbox debugging instance has a built-in data anonymization engine that automatically performs anonymization processing on user information and business data involved in the debugging process, effectively mitigating the risk of data leakage.
[0066] S107. Synchronize the associated service data of the target agent's skills in the production environment to the test associated service.
[0067] In one embodiment, prior to S103, the method further includes S108.
[0068] S108. Set the configuration information of the target agent's skills to read-only.
[0069] To ensure that the configuration information of the target agent skill is not modified during the debugging process, this embodiment sets the configuration information of the target agent skill to a read-only state. In other words, this embodiment intercepts all editing, modification, deletion, and regeneration operations on the target agent skill, and grays out the configuration items of the target agent skill, making them uneditable and thus removing any operation buttons. When a user wants to modify the configuration information of the target agent skill during debugging, a prompt appears stating, "Configuration is locked in debugging mode; modification is prohibited. Editing permissions will be automatically released after exiting debugging." By locking the configuration in debugging mode, users are prevented from accidentally modifying the configuration during debugging, which could lead to abnormal debugging process logic and ensure the stability and consistency of the debugging process. In one embodiment, the method further includes: S109-S110.
[0070] S109. Obtain the execution status information of the running instance.
[0071] S110. Display execution status information through a visual interface.
[0072] In one embodiment, the target intelligent agent skill includes multiple functional nodes, and the execution status information includes the execution status information of each of the multiple functional nodes. The above S110 specifically includes the following steps: S111-S112.
[0073] S111. Construct multiple interconnected visual cards based on the execution order of multiple functional nodes.
[0074] Multiple visual cards correspond one-to-one with multiple functional nodes.
[0075] S112. Display the execution status information of the corresponding functional node on each of the multiple visualization cards.
[0076] It should be noted that S111-S112 will be explained in detail below.
[0077] In this embodiment, a visual card is created for each functional node, and these visual cards are connected together according to the execution order of each functional node. When the target agent skill is running in the debugging process, each functional node will update the execution status information of the corresponding visual card in real time according to the current skill execution flow.
[0078] In one embodiment, the plurality of functional nodes includes a target functional node, and S112 specifically includes the following steps: S1121-S1124.
[0079] S1121. If the running instance reaches the target function node, the first identifier will be displayed on the visualization card corresponding to the target function node.
[0080] The first identifier is used to indicate that the target functional node is in the execution state.
[0081] S1122. If the running instance executes successfully on the target functional node, the second identifier is displayed on the visualization card corresponding to the target functional node.
[0082] The second identifier is used to indicate that the target function node has been successfully executed.
[0083] S1123. If the running instance fails to execute on the target functional node, a third identifier will be displayed on the visualization card corresponding to the target functional node.
[0084] The third identifier is used to indicate that the target function node is in a failed execution state.
[0085] S1124. If the running instance does not reach the target function node, the fourth identifier will be displayed on the visualization card corresponding to the target function node.
[0086] The fourth identifier is used to indicate that the target function node is in an inactive state.
[0087] It should be noted that S1121-S1124 will be explained in detail below.
[0088] The first, second, third, and fourth identifiers can all be represented using text or color. For example, "Executing" can be used to represent the first identifier, or yellow can be used to represent the first identifier. Users can directly perceive the execution status of each node by observing the identifier information displayed on the visual card corresponding to each node.
[0089] In addition, in this embodiment, execution results and exception information can also be displayed on the visualization card for user debugging. This embodiment deeply integrates the visualization of execution status with the business function configuration area. The node status corresponds one-to-one with the node position in the configuration interface. Users can intuitively see the process execution progress without switching pages, and can easily locate the faulty node when an exception occurs. In one embodiment, the method further includes: S113.
[0090] S113. After the running instance finishes running, destroy the sandbox debugging instance.
[0091] Specifically, the system automatically triggers the instance destruction process when the user manually exits debugging or when there is no operation for more than 30 minutes after the debugging process ends. This process includes, but is not limited to, deleting shadow instances, clearing temporary library data, cleaning up network rules, and releasing namespaces, ensuring complete resource recovery with no residual data or processes. Simultaneously, all debugging logs and execution results are archived and permanently stored for future backtracking.
[0092] In one embodiment, the method further includes: S114.
[0093] S114. After the running instance finishes running, set the configuration information of the target agent's skills to a read-write state.
[0094] After the instance finishes running, the configuration information of the target agent's skills is restored to a read-write state. Users can modify the configuration information and re-run the instance based on the running results.
[0095] See Figure 2 , Figure 2This is a schematic block diagram of a visualization debugging device for intelligent agent skills provided in an embodiment of this application. Corresponding to the above-described visualization debugging method for intelligent agent skills, this application also provides a visualization debugging device for intelligent agent skills. This visualization debugging device for intelligent agent skills includes a unit for executing the above-described visualization debugging method for intelligent agent skills, and can be configured in terminals such as desktop computers, tablet computers, and laptops. Specifically, the visualization debugging device for intelligent agent skills includes: Execution unit 201 is used to respond to the user selecting the target simulation device type in the debugging interaction tab area and triggering the start debugging operation to perform preset debugging pre-verification on the target intelligent agent's skills; The first construction unit 202 is used to construct a sandbox debugging instance if the result of the preset debugging pre-verification is passed. The second construction unit 203 is used to construct a debugging environment for the target agent skill in the sandbox debugging instance, the debugging environment including a running instance of the target agent skill; The third construction unit 204 is used to construct a simulated terminal device based on the target simulated device type; The receiving unit 205 is configured to receive debugging instructions input by the user on the interface of the simulated terminal device and forward the debugging instructions to the running instance, wherein the debugging instructions are used to verify the execution status of the running instance.
[0096] In one embodiment, the execution unit 201 is specifically used for: Obtain the full lifecycle state and configuration information of the target intelligent agent's skills; Perform an integrity check on the configuration information; If the full lifecycle status is a draft status, and the integrity verification result is passed, then the result of the preset debugging pre-verification is determined to be passed. If the full lifecycle status is a non-draft status, or if the integrity verification result is a failure, then the result of the preset debugging pre-verification is determined to be a failure.
[0097] In one embodiment, the second building unit 203 is specifically used for: Obtain the configuration information of the target agent's skills; The target agent skill is deployed in the sandbox debugging instance according to the configuration information to form a running instance of the target agent skill.
[0098] In one embodiment, the debugging environment further includes a test association service for the target agent's skills, and the apparatus further includes: Deployment unit 206 is used to deploy the associated services of the target agent's skills in the sandbox debugging instance to form the test associated services; Synchronization unit 207 is used to synchronize the associated service data of the target intelligent agent's skills in the production environment to the test associated service.
[0099] In one embodiment, before building the debugging environment for the target agent's skill in the sandbox debugging instance, the apparatus further includes: Setting unit 208 is used to set the configuration information of the target intelligent agent's skills to read-only state.
[0100] In one embodiment, the device further includes: The acquisition unit 209 is used to acquire the execution status information of the running instance; The display unit 210 is used to display the execution status information through a visual interface.
[0101] In one embodiment, the target intelligent agent skill includes multiple functional nodes, and the execution state information includes the execution state information of each of the multiple functional nodes. The display unit 210 is specifically used for: Multiple interconnected visualization cards are constructed according to the execution order of the multiple functional nodes, and the multiple visualization cards correspond one-to-one with the multiple functional nodes; Each of the multiple visualization cards displays the execution status information of the functional node corresponding to that visualization card.
[0102] In one embodiment, the plurality of functional nodes includes a target functional node, and the display unit 210 is further specifically used for: If the running instance reaches the target function node, a first identifier is displayed on the visualization card corresponding to the target function node. The first identifier is used to indicate that the target function node is in the execution state. If the running instance executes successfully on the target functional node, a second identifier is displayed on the visualization card corresponding to the target functional node. The second identifier is used to indicate that the target functional node is in a successful execution state. If the running instance fails to execute on the target functional node, a third identifier is displayed on the visualization card corresponding to the target functional node. The third identifier is used to indicate that the target functional node is in an execution failure state. If the running instance does not reach the target function node, a fourth identifier is displayed on the visualization card corresponding to the target function node. The fourth identifier is used to indicate that the target function node is in an inactive state.
[0103] In one embodiment, the device further includes: The destruction unit 211 is used to destroy the sandbox debugging instance after the running instance finishes running.
[0104] In one embodiment, the setting unit 208 is further configured to: After the running instance finishes running, the configuration information of the target agent's skills is set to a read-write state.
[0105] like Figure 3 As shown, this application provides a computer device including a processor 31, a communication interface 32, a memory 33, and a communication bus 34. The processor 31, the communication interface 32, and the memory 33 communicate with each other through the communication bus 34. The memory 33 is used to store computer programs. In one embodiment of this application, when the processor 31 executes the program stored in the memory 33, it implements the control method for visual debugging of intelligent agent skills provided in any of the foregoing method embodiments.
[0106] It will be understood by those skilled in the art that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program may be stored in a storage medium, which is a computer-readable storage medium. The computer program is executed by at least one processor in the computer system to implement the process steps of the embodiments of the above methods.
[0107] Therefore, embodiments of this application also provide a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the visualization debugging method for intelligent agent skills provided in any of the foregoing method embodiments.
[0108] The storage medium is a physical, non-transient storage medium, such as a USB flash drive, external hard drive, read-only memory (ROM), magnetic disk, or optical disk, or any other physical storage medium capable of storing program code. The computer-readable storage medium can be non-volatile or volatile.
[0109] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this application.
[0110] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative. For example, the division of each unit is merely a logical functional division, and there may be other division methods in actual implementation. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed.
[0111] The steps in the methods of this application embodiment can be adjusted, merged, or deleted according to actual needs. The units in the apparatus of this application embodiment can be merged, divided, or deleted according to actual needs. Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.
[0112] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, a terminal, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application.
[0113] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.
[0114] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Since these modifications and variations fall within the scope of the claims and their equivalents, this application also intends to include these modifications and variations.
[0115] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any person skilled in the art can easily conceive of various equivalent modifications or substitutions within the technical scope disclosed in this application, and these modifications or substitutions should all be covered within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.
Claims
1. A visual debugging method for intelligent agent skills, characterized in that, include: In response to the user selecting the target simulation device type in the debug interaction tab area and triggering the start debug operation, a preset debug pre-verification is performed on the target intelligent agent's skills; If the result of the preset debugging pre-verification is passed, then a sandbox debugging instance is constructed; In the sandbox debugging instance, a debugging environment for the target agent skill is constructed, and the debugging environment includes a running instance of the target agent skill; Construct a simulation terminal device based on the target simulation device type; The system receives debugging commands input by the user on the interface of the simulated terminal device and forwards the debugging commands to the running instance. The debugging commands are used to verify the execution status of the running instance. The aforementioned pre-debugging verification of the target agent's skills includes: Obtain the full lifecycle state and configuration information of the target intelligent agent's skills; Perform an integrity check on the configuration information; If the full lifecycle status is a draft status, and the integrity verification result is passed, then the result of the preset debugging pre-verification is determined to be passed. If the full lifecycle status is a non-draft status, or if the integrity verification result is a failure, then the result of the preset debugging pre-verification is determined to be a failure. The method further includes, before constructing the debugging environment for the target agent's skill in the sandbox debugging instance: Set the configuration information of the target agent's skills to read-only.
2. The method according to claim 1, characterized in that, The debugging environment for constructing the target agent's skills in the sandbox debugging instance includes: Obtain the configuration information of the target agent's skills; The target agent skill is deployed in the sandbox debugging instance according to the configuration information to form a running instance of the target agent skill.
3. The method according to claim 2, characterized in that, The debugging environment also includes a test association service for the target agent's skills, and the method further includes: Deploy the associated services of the target agent's skills in the sandbox debugging instance to form the test associated services; Synchronize the associated service data of the target agent's skills in the production environment to the test associated service.
4. The method according to claim 1, characterized in that, The method further includes: Obtain the execution status information of the running instance; The execution status information is displayed through a visual interface.
5. The method according to claim 4, characterized in that, The target intelligent agent skill includes multiple functional nodes, and the execution status information includes the execution status information of each of the multiple functional nodes. Displaying the execution status information through a visual interface includes: Multiple interconnected visualization cards are constructed according to the execution order of the multiple functional nodes, and the multiple visualization cards correspond one-to-one with the multiple functional nodes; Each of the multiple visualization cards displays the execution status information of the functional node corresponding to that visualization card.
6. The method according to claim 5, characterized in that, The plurality of functional nodes include target functional nodes, and the display of the execution status information of the functional node corresponding to the visualization card on each of the plurality of visualization cards includes: If the running instance reaches the target function node, a first identifier is displayed on the visualization card corresponding to the target function node. The first identifier is used to indicate that the target function node is in the execution state. If the running instance executes successfully on the target functional node, a second identifier is displayed on the visualization card corresponding to the target functional node. The second identifier is used to indicate that the target functional node is in a successful execution state. If the running instance fails to execute on the target functional node, a third identifier is displayed on the visualization card corresponding to the target functional node. The third identifier is used to indicate that the target functional node is in an execution failure state. If the running instance does not reach the target function node, a fourth identifier is displayed on the visualization card corresponding to the target function node. The fourth identifier is used to indicate that the target function node is in an inactive state.
7. The method according to claim 1, characterized in that, The method further includes: After the running instance finishes running, the sandbox debugging instance is destroyed.
8. The method according to claim 1, characterized in that, The method further includes: After the running instance finishes running, the configuration information of the target agent's skills is set to a read-write state.