Method, device, equipment and product for generating flow chart

Abstract

The invention relates to a method, a device, equipment and a product for generating a flow chart. The method includes generating code in response to a user's input for creating code for processing a transaction. The method further includes parsing the code to generate a flow chart of the code, the flow chart indicating the plurality of nodes. Further, the method includes displaying a flow chart, where at least one node of the plurality of nodes in the displayed flow chart has user interactivity. Through the method, the understanding difficulty of the user on the service is reduced, and the working efficiency of the user is improved.

Description

Technical Field

[0001] This disclosure generally relates to the field of computers, and more specifically to methods, apparatus, devices, and computer program products for generating flowcharts. Background Technology

[0002] In the current software development field, especially in complex front-end applications and back-end workflow construction scenarios involving collaboration among multiple roles (such as product managers, designers, and R&D engineers), there is a method of generating a domain-specific language (DSL) from natural language. This technical approach aims to lower the barrier to software development, allowing business personnel or product managers without professional programming backgrounds to build application logic through a graphical interface. Natural language input drives the generation of a dedicated DSL or graph structure from a large model, which is then rendered, executed, or deployed by the system or engine.

[0003] Another approach involves first generating executable code (e.g., scripts, function calls, task logic) through a natural language input-driven model. The system then abstracts a flowchart or process structure from this code and presents it in the form of a graph or directly generated mind map (Mermaid) syntax. This method treats the definition of workflow or business logic as standard software engineering code. Developers use general-purpose programming languages ​​such as Python to build the workflow logic and generate corresponding flowcharts by calling specific libraries. Summary of the Invention

[0004] In embodiments of this disclosure, a method, apparatus, electronic device, and computer program product for generating flowcharts are provided.

[0005] In a first aspect of this disclosure, a method for generating a flowchart is provided. The method includes generating code in response to user input for creating code to process transactions. The method also includes parsing the code to generate a flowchart of the code, the flowchart indicating multiple nodes. Furthermore, the method includes displaying the flowchart, wherein at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0006] In a second aspect of this disclosure, an electronic device is provided. The electronic device includes a generation module configured to generate code in response to user input for creating code for processing transactions. The electronic device also includes a parsing module configured to parse the code to generate a flowchart indicating multiple nodes. Furthermore, the electronic device includes a display module configured to display the flowchart, wherein at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0007] In a third aspect of this disclosure, an electronic device is provided. The electronic device includes a processor. The electronic device also includes a memory coupled to the processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to a first aspect of this disclosure.

[0008] In a fourth aspect of this disclosure, a computer program product is provided, comprising computer-executable instructions, wherein the computer-executable instructions are executed by a processor to implement the method according to a first aspect of this disclosure.

[0009] In a fifth aspect of this disclosure, a computer-readable storage medium is provided. The computer-readable storage medium stores computer-executable instructions, which are executed by a processor to implement the method according to the first aspect.

[0010] The summary section is intended to present the chosen concepts in a simplified form, which will be further described in the detailed description below. The summary section is not intended to identify key or principal features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter. Attached Figure Description

[0011] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. In the drawings, the same or similar reference numerals denote the same or similar elements, wherein:

[0012] Figure 1 A schematic diagram is shown illustrating an example environment in which one or more embodiments of the present disclosure may be implemented;

[0013] Figure 2 Flowcharts illustrating methods for generating flowcharts according to some embodiments of this disclosure are shown;

[0014] Figure 3 A block diagram of a system architecture for generating flowcharts according to some embodiments of the present disclosure is shown;

[0015] Figure 4 A block diagram of an interactive module for generating flowcharts according to some embodiments of the present disclosure is shown;

[0016] Figure 5 A schematic diagram illustrating a method for selecting multiple nodes of a flowchart generated according to some embodiments of the present disclosure for trial operation;

[0017] Figure 6 A schematic diagram illustrating a method for trial operation of multiple nodes of a flowchart generated according to some embodiments of the present disclosure is shown;

[0018] Figure 7 A block diagram of an interactive module for generating flowcharts and tracing interactions, according to some embodiments of the present disclosure, is shown.

[0019] Figure 8 A schematic diagram illustrating a method for selecting multiple nodes of a flowchart generated according to some embodiments of the present disclosure is shown;

[0020] Figure 9 A schematic diagram illustrating a method for modifying multiple nodes of a flowchart generated according to some embodiments of the present disclosure is shown.

[0021] Figure 10 A block diagram of an apparatus for generating flowcharts according to some embodiments of the present disclosure is shown; and

[0022] Figure 11 A schematic block diagram of an electronic device according to some embodiments of the present disclosure is shown.

[0023] In all the accompanying figures, the same or similar reference numerals denote the same or similar elements. Detailed Implementation

[0024] It is understood that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) shall comply with the requirements of relevant laws, regulations and related provisions.

[0025] It is understood that before using the technical solutions disclosed in the various embodiments of this disclosure, users should be informed of the types, scope of use, and usage scenarios of the personal information involved in this disclosure in an appropriate manner in accordance with relevant laws and regulations, and user authorization should be obtained.

[0026] For example, upon receiving a user's proactive request, a prompt message is sent to the user to explicitly inform them that the requested operation will require the acquisition and use of the user's personal information. This allows the user to independently choose whether to provide personal information to the software or hardware, such as the electronic device, application, server, or storage medium performing the operations of this disclosed technical solution, based on the prompt message.

[0027] As an optional but non-limiting implementation, in response to a user's active request, sending a prompt message to the user can be done via a pop-up window, where the prompt message can be presented in text format. Furthermore, the pop-up window can also include a selection control allowing the user to choose "agree" or "disagree" to provide personal information to the electronic device.

[0028] It is understood that the above notification and user authorization process are merely illustrative and do not constitute a limitation on the implementation of this disclosure. Other methods that comply with relevant laws and regulations may also be applied to the implementation of this disclosure.

[0029] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0030] In the description of embodiments of this disclosure, the term "comprising" and similar terms should be understood as open-ended inclusion, i.e., "including but not limited to". The term "based on" should be understood as "at least partially based on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The terms "first", "second", etc., may refer to different or the same objects unless explicitly stated. Other explicit and implicit definitions may also be included below.

[0031] As mentioned above, there are currently methods for generating workflow DSLs using natural language. The problem with this approach is that users still need to understand the syntax, conventions, and semantics of the DSL. The DSL relies on predefined human input, which limits the model's generation capabilities in task-oriented scenarios. Furthermore, this approach has poor scalability when encountering complex logic. For example, when logic is highly nested, conditions are complex, or loops are multi-level, the DSL often becomes difficult to express or becomes bloated. This approach also requires a dedicated mapping from the DSL to the execution engine, and maintaining compatibility, versioning, and iteration between the DSL and the execution engine is a significant burden. In addition, model generation error rates still exist. For example, although the DSL is structured, if the language model does not understand it accurately during generation, it may still lead to grammatical errors and logical inconsistencies. Moreover, this method also suffers from layout and rendering performance bottlenecks. For example, when the workflow becomes extremely complex, the computational overhead of the automatic layout algorithm for freely laid-out canvases is high, and it may produce intersecting and messy connections, affecting readability and causing front-end rendering performance issues.

[0032] Another approach involves first generating executable code (e.g., scripts, function calls, task logic) through a natural language input-driven model. The system then abstracts flowcharts or process structures from this code and presents them in the form of graphs or directly generated mind maps (Mermaid). The problem with this approach is the lack of observability in graph language descriptions. For example, the graph language generated by reverse-rendering the code undergoes high compression of the large model, which to some extent masks a large amount of engineering details, failing to meet the iterative maintenance needs of production scenarios. Furthermore, there is a disconnect between the code and the visualization output. The flowcharts and other visual documents generated by this approach are static and one-off. When developers modify the code, the flowcharts cannot be automatically updated, leading to inconsistencies between the documentation and the actual logic. This increases the difficulty of understanding and collaboration for team members (especially business personnel), and also increases project handover and later maintenance costs. Moreover, this approach lacks a unified collaboration and observation platform. For example, there is a lack of a unified and flexible view among developers, machine learning model agents, and business personnel to jointly review and operate the workflow. Developers struggle with the details of the code, while business personnel cannot intuitively verify whether the process meets expectations.

[0033] Therefore, to address at least one of the aforementioned problems, one or more embodiments of this disclosure provide a method or system for generating flowcharts, employing an alternative approach. This method generates business or transaction code, parses the code to generate a flowchart, and displays an interactive flowchart. This reduces the difficulty for users to understand the business logic and significantly improves the user experience.

[0034] To this end, one or more embodiments of this disclosure provide a scheme for generating flowcharts. The scheme includes generating code in response to user input for creating code to process transactions. The scheme also includes parsing the code to generate a flowchart of the code, the flowchart indicating multiple nodes. The scheme further includes displaying the flowchart, wherein at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0035] In this way, one or more embodiments of this disclosure provide a method for generating flowcharts, etc., by taking an alternative approach. One or more embodiments of this disclosure generate business logic code, parse the code to generate flowcharts, and display interactive flowcharts. This reduces the difficulty for users to understand the business logic and greatly improves the user experience.

[0036] Figure 1 A schematic diagram of an example environment 100 in which one or more embodiments of the present disclosure may be implemented is shown. Figure 1As shown, environment 100 includes processing device 102. Processing device 102 can be any device with processing capabilities. For example, processing device 102 can include smartphones, tablets, laptops, desktop computers, workstations, or smart wearable devices. In environment 100, processing device 102 can run application 104, for example, application 104 can be an integrated development environment (IDE) application. User 108 can interact with application 104 through processing device 102. In application 104, the user can perform application or project development, etc. Application 104 can include flowchart generation module 106 according to one or more embodiments of this disclosure. Flowchart generation module 106 can generate flowcharts of relevant workflows or transactions based on agent 110 and based on interactions with user 108. In some embodiments, agent 110 can be one or more machine learning model agents. In some embodiments, user 108 can also interact with at least one node in the generated flowchart through flowchart generation module 106, etc. Because the flowchart generated by the flowchart generation module 106 includes at least one node that allows interaction with the user 108, it reduces the difficulty for the user to understand the business logic and greatly improves the user experience. Furthermore, the flowchart generation module 106 can also function as an independent application, rather than simply being a flowchart generation module within application 104.

[0037] It should be understood that, for the sake of brevity, Figure 1 Only a specific number of processing devices 102, applications 104, flowchart generation modules 106, and agents 110 are shown in this document, but it is not intended to limit the number of processing devices 102, applications 104, flowchart generation modules 106, and agents 110. In other implementations, any number of processing devices 102, applications 104, flowchart generation modules 106, and agents 110 applicable to this disclosure may be used. For example, processing device 102 may also be a cloud computing platform, etc.

[0038] In this way, the environment 100 containing the flowchart generation module 106 implemented in one or more embodiments of this disclosure provides a method for generating flowcharts through an alternative approach. The environment 100 containing the flowchart generation module 106 implemented in one or more embodiments of this disclosure generates business code, parses the code to generate a flowchart, and displays a flowchart that can be interacted with by the user. This reduces the difficulty for users to understand the business logic and greatly improves the user experience.

[0039] The following will combine Figures 2 to 11The process according to embodiments of this disclosure is described in detail. For ease of understanding, the specific data mentioned in the following description are exemplary and not intended to limit the scope of this disclosure. It should be understood that the embodiments described below may also include additional actions not shown and / or actions shown may be omitted, and the scope of this disclosure is not limited in this respect.

[0040] Figure 2 A flowchart of a method 200 for generating a flowchart, according to some embodiments of the present disclosure, is shown. Method 200 can be executed by a processing device. For example, method 200 can be performed by… Figure 1 The processing device 102 performs the operation. The processing device may include, for example, a smartphone, tablet computer, laptop computer, desktop computer, workstation, quantum computer, cloud computing platform, or smart wearable device.

[0041] In box 202, code is generated in response to user input regarding the creation of code for handling transactions. In some embodiments, generating code in response to user input regarding the creation of code for handling transactions may include receiving natural language-based input from a user (e.g., user 108) regarding the creation of code for handling transactions, and generating code via an agent based on the received natural language-based input from the user regarding the creation of code for handling transactions. In some embodiments, the agent may be... Figure 1 The agent 110 shown is an agent for one or more machine learning models. In some embodiments, a user can directly use natural language as prompts, and the agent 110 can generate code for processing transactions based on those natural language prompts. In some embodiments, in response to user input for creating code for processing transactions, generating code may further include generating modified code via the agent in response to a user's request to modify the code based on natural language.

[0042] In box 204, the code is parsed to generate a flowchart indicating multiple nodes. In some embodiments, the flowchart includes JSON data. In some embodiments, the flowchart may include nodes and connecting lines between nodes. In some embodiments, at least one of the multiple nodes in the flowchart is user-interactive. In some embodiments, the flowchart can be updated according to modified code. In some embodiments, the flowchart can be rendered and displayed.

[0043] In box 206, a flowchart is displayed, wherein at least one of the plurality of nodes in the displayed flowchart is user-interactive. In some embodiments, displaying the flowchart includes drawing the nodes of the flowchart and the connecting lines between the nodes using a predetermined layout algorithm. In some embodiments, the predetermined layout algorithm is a deterministic layout algorithm that ensures that the same flowchart data always generates the same layout.

[0044] In some embodiments, method 200 may further include running the node in response to a user's request to run the node. In some embodiments, running the node in response to a user's request to run the node may include highlighting the running status of the running node in response to the running node request. In some embodiments, running the node in response to a user's request to run the node may further include determining a detailed description of the running status of the node through an agent in response to a user's request for the running status of the node, and displaying a detailed description of the running status of the node. In some embodiments, running the node in response to a user's request to run the node may further include recording the process of running the node, or displaying the recording process in response to a user's access request for the recorded process. In some embodiments, running the node in response to a user's request to run the node may further include receiving user input data in response to a user's request to run the node, running the node based on the user's input data, and displaying output data after running the node in response to the user's request to run the node.

[0045] In some embodiments, method 200 may further include, in response to a user's request for at least one of the nodes, receiving modifications made by the user to at least one node, and generating modified code based on the user's modifications to at least one node. In some embodiments, generating modified code based on the user's modifications to at least one node may include, based on the user's modifications to at least one node and the code, incrementally modifying the modified at least one node via a proxy to generate the modified code. In some embodiments, the flowchart for parsing the code to generate the code may include parsing the modified code to generate the modified flowchart. In some embodiments, the flowchart for displaying the code may include displaying the modified flowchart, wherein the modified flowchart includes the modified at least one node. In some embodiments, displaying the flowchart for displaying the code may further include comparing the flowchart and the modified flowchart, determining the differences between the flowchart and the modified flowchart, and displaying the modified flowchart based on the determined differences between the flowchart and the modified flowchart.

[0046] In this way, one or more embodiments of method 200 provide a novel approach to generating flowcharts. One or more embodiments of method 200 generate business logic code, parse the code to generate a flowchart, and display an interactive flowchart. This achieves automatic flowchart generation and display, enhances user interaction with the flowchart, reduces the difficulty for users to understand the business logic, and significantly improves the user experience. Furthermore, because one or more embodiments of method 200 provide convenient ways to modify the code and flowchart, users also significantly reduce product development and maintenance costs and improve work efficiency.

[0047] Figure 3 A block diagram of a system architecture 300 for generating flowcharts according to some embodiments of the present disclosure is shown. System architecture 300 may include an agent 310, an IDE application 304, and a visualization interface 306 embedded in the flowchart generation module of the IDE application 304. In some embodiments, agent 310 may be a machine learning model agent capable of understanding natural language instructions, responsible for generating and modifying workflow code, and parsing a flowchart or process structure based on the code according to an algorithm. The flowchart may include, for example, JSON data. The JSON data included in the flowchart may be rendered or displayed in a canvas included in the visualization interface 306. The JSON data included in the flowchart may serve as a schema for rendering or displaying the canvas included in the visualization interface 306. In some embodiments, visualization interface 306 may be embedded in the IDE application 304. Visualization interface 306 may include a canvas (not shown), which may serve as a front-end interaction layer for interactive orchestration with the user. Visualization interface 306 is responsible for receiving and rendering the schema of the canvas to form a user-visible flowchart with a fixed layout. In some embodiments, the IDE application 304 can provide a unified runtime platform, file system, and communication services (such as WebSocket, HTTP, SSE, etc.) as the infrastructure for front-end and back-end collaboration.

[0048] Figure 4 A block diagram of an interactive module 400 for generating flowcharts according to some embodiments of the present disclosure is shown. Figure 4As shown, the interaction module 400 may include a main interface 401, which is embedded in the IDE application architecture. The main interface 401 may include an initial request module 403 for the user to input initial requests to the agent, a flowchart display area or canvas 405 for rendering and displaying flowcharts, etc., and a modification and testing module 409 for receiving user input to modify or test code or flowcharts. The main interface 401 may also include any other suitable or beneficial modules for generating flowcharts. For example, the main interface 401 may include a file management module for code or flowcharts (not shown), etc. In some embodiments, in the initial request module 403, the user can send a request 411, based on natural language, to the agent in the background to generate corresponding code for a transaction or workflow described in natural language. For example, the user can make a request such as "Help me develop a news assistant..." The background agent can then receive the request 411 and provide a response 413. For example, the background agent can reply "Okay...". At 417, the agent's running status can be displayed, such as "Development completed...". The backend agent can be one or more machine learning models, such as a Large Language Model (LLM). The backend agent can generate corresponding code based on user requests and parse the code into a corresponding flowchart. The flowchart may include, for example, JSON data. The JSON data included in the flowchart can serve as a schema for rendering or displaying on canvas 405.

[0049] In some embodiments, after receiving the flowchart data, the main interface 401 can render or display the flowchart on the canvas 405 based on the schema. In some embodiments, flowchart 419 is displayed on the canvas 405. Flowchart 419 indicates the main nodes of the news assistant. For example, at node 421, the user can enter search terms to search for news. At node 423, the background agent can search for relevant news. At node 425, the news type is determined. Further, an application research report is generated at node 427, or a model evaluation is generated at node 429. At node 431, specific content is generated. And at node 433, the generated content is published. Finally, at node 435, the generated content and the corresponding title are output. It is worth noting that the nodes of flowchart 419 are merely exemplary. Those skilled in the art can generate any flowchart suitable for this disclosure based on the background agent according to actual needs. Any flowchart suitable for this disclosure should be within the protection scope of this disclosure. In some embodiments, at least one node of flowchart 419 can be tested through the test run control 407. As for how to test run at least one node of flowchart 419, it will be explained in detail below, and will not be repeated here.

[0050] In some embodiments, the main interface 401 may further include a modification and testing module 409 that can receive user input to modify or test code or flowcharts. The modification and testing module 409 may include a dialog modification control 437 and a test control 439. In some embodiments, through the dialog modification control 437, users can modify the code and flowchart 419 via a background agent through a dialogue. In some embodiments, users can modify the code and flowchart via a background agent using natural language through a dialogue. Modifications to the code or flowchart can be directly updated in the canvas 405, thereby displaying the corresponding modifications and greatly improving the user experience. In some embodiments, users can run at least one node of the flowchart 419 through the test control 439. For example, users can input corresponding parameters in the input control 441, and at least one node of the flowchart 419 can receive the user-input parameters, run the program, and output the result of that node to the control 443. In this way, users can specifically understand the results of their transaction resolution, thereby better understanding the various nodes in the flowchart.

[0051] Therefore, the foundational data for the interaction module 400 is the schema of canvas 405, which can be a standardized JSON dataset serving as a unified basis for decoupling the front-end and back-end. After the proxy generates code, it synchronously maps or updates this schema, and the interaction module 400 renders according to this schema, ensuring consistency between the visual presentation and the underlying code logic. The entire system handles real-time interactions such as trial runs through a unified WebSocket channel, and handles request / response or streaming push tasks such as schema retrieval and node interpretation through an HTTP / SSE channel.

[0052] Therefore, the interaction module 400 constructs a complete closed loop from user requirements to feature launch and continuous iteration. For example, users input initial requirements in the IDE dialog box and clarify or explain their true needs. The agent receives the requirements, plans and calls the toolset to generate workflow code, and then immediately reverse-engineers the code to produce the latest canvas schema. The canvas provides a set of standardized process node components (such as start, end, task, condition, loop, etc.), each component is responsible for rendering its specific user interface (UI) form. It can also automatically draw connection lines between nodes and handle states such as highlighting and animation, using deterministic layout algorithms (e.g., FlowGram) to ensure that the same schema always generates the exact same layout, facilitating the agent's understanding and generation, and fundamentally avoiding the performance overhead of free layout.

[0053] In this way, one or more embodiments of the interaction module 400 provide a novel method for generating flowcharts. One or more embodiments of the interaction module 400 generate business logic code, parse the code to generate a flowchart, and display the flowchart in a way that allows for user interaction. This achieves automatic generation and display of the flowchart, enhances user interaction with the flowchart, reduces the difficulty for users to understand the business logic, and significantly improves the user experience. Furthermore, because one or more embodiments of the interaction module 400 provide convenient ways to modify the code and flowchart, users also significantly reduce product development and maintenance costs and improve work efficiency.

[0054] To help those skilled in the art understand how to trial-run at least one node of a flowchart generated according to some embodiments of this disclosure, the following will be combined with Figure 5 and 6 Please provide a detailed explanation. Figure 5 A schematic diagram of a method 500 for selecting multiple nodes of a flowchart generated according to some embodiments of the present disclosure for trial operation is shown. Figure 6 This illustration shows a schematic diagram of a method 600 for piloting multiple nodes of a flowchart generated according to some embodiments of the present disclosure. It is worth noting that those skilled in the art may select one or more nodes for piloting. This disclosure does not impose any limitations in this regard.

[0055] exist Figure 5 In the flowchart displayed on the canvas, the user selects nodes 525, 527, 529, and 531 using selection boxes. The user wants to test the validity of the corresponding code by running these nodes 525, 527, 529, and 531. In some embodiments, in response to the user completing the node selection, the corresponding test run control 507 can be displayed. If the user clicks the test run control 507, the system's main interface will redirect to... Figure 6 middle.

[0056] In response to the user clicking the trial run control 507, the system's main interface redirects to... Figure 6 In. Figure 6The interactive module for user interaction may include a main interface 601, which is embedded in the IDE application architecture. The main interface 601 may include a flowchart display area or canvas 605 for rendering and displaying flowcharts, and a modification / testing module 609 for receiving user input to modify or test code or flowcharts. The main interface 601 may also include any other suitable or beneficial modules for generating flowcharts. For example, the main interface 601 may include a file management module for code or flowcharts (not shown). Flowchart 619 is displayed on canvas 605. Since the user has selected nodes 625, 627, 629, 631, and 633 in flowchart 619, the user can test nodes 625, 627, 629, 631, and 633 in the modification / testing module 609. The user can input various parameters or constraints required for the test run in the test run input control 641 indicated by the static text box 640 for test run input. This disclosure does not limit the type of input. Those skilled in the art can determine the inputs of the nodes as needed, and any inputs suitable for this disclosure should be within the scope of protection of this disclosure.

[0057] from Figure 6 As can be seen in some embodiments, nodes 625, 627, 629, 631, and 633 display the running status and running time. For example, nodes 625, 627, 629, 631, and 633 may display "Using a search engine to search..." and have been running for "12 seconds". The test run output control 643, indicated by the static text box 642 of the test run output, can display the output results of running nodes 625, 627, 629, 631, and 633. In some embodiments, optionally, the modified test module 609 may also include another test run control 647. After completing the input, the user can also initiate a test run on the selected node by clicking the test run control 647. In some embodiments, optionally, the user can also initiate a test run on the selected node by clicking the test run control 607.

[0058] Therefore, methods 500 and 600 can validate the flowchart and code through visual trial runs. For example, the interactive module pulls and renders the latest schema, allowing users to visually inspect the logic. Subsequently, users can trigger global or single-node trials through the main interface 601. Nodes on the canvas 605 will be highlighted based on the real-time returned running status (success / failure), such as dynamically highlighting relevant nodes or connecting lines, and the input or output data in the modification test module 609 will be displayed. In some embodiments, for users who need to understand more detailed code execution details, a large model can be invoked with a single click for quick explanation, thus providing a detailed description.

[0059] In this way, one or more embodiments of methods 500 and 600 provide a novel approach to generating flowcharts. One or more embodiments of methods 500 and 600 generate business logic code, parse the code to generate a flowchart, and display an interactive flowchart. This achieves automatic flowchart generation and display, enhances user interaction with the flowchart, reduces the difficulty for users to understand the business logic, and significantly improves the user experience. Furthermore, because one or more embodiments of methods 500 and 600 provide convenient ways to modify and test the code and flowchart, users also significantly reduce product development and maintenance costs and improve work efficiency.

[0060] Figure 7 A block diagram of an interaction module 700 for generating flowcharts and tracking interactions, according to some embodiments of the present disclosure, is shown. Figure 7 As shown, the interaction module 700 may include a main interface 701, which is embedded in the IDE application architecture. The main interface 701 may include an initial request module 703 for the user to input initial requests to the agent, a flowchart display area or canvas 705 for rendering and displaying flowcharts 719, a modification and testing module 709 for receiving user input to modify or test code or flowcharts, and a running record module 721 for recording the execution status of each node or code in flowchart 719. The main interface 701 may also include any other suitable or beneficial modules for generating flowcharts. For example, the main interface 701 may include a file management module for code or flowcharts (not shown). In some embodiments, the running record module 721 can record the execution status of each node or code in flowchart 719 in a timely manner for archiving and subsequent verification, thereby enabling the tracking of problematic nodes. In some embodiments, the detailed process of each trial run is recorded as a Trace, and users can review the historical records at any time in the run record module 721 to view information such as the input, output, and time consumption of each node, and quickly locate problems. This meets the requirements of production-level scenarios for process observability, and is also visual and user-friendly.

[0061] In some embodiments, when a problem is detected, the user can select one or more relevant nodes on the canvas for modification. To help those skilled in the art understand how to modify at least one node of a flowchart generated according to some embodiments of this disclosure, the following will be combined with... Figure 8 and 9 Please provide a detailed explanation. Figure 8 A schematic diagram of a method 800 for selecting multiple nodes of a flowchart generated according to some embodiments of the present disclosure is shown. Figure 9This illustration shows a method 900 for modifying multiple nodes of a flowchart generated according to some embodiments of the present disclosure. It is worth noting that those skilled in the art may select one or more nodes for modification. This disclosure does not impose any limitations in this regard.

[0062] exist Figure 8 In this system, the interaction module may include a main interface 801, which is embedded in the IDE application architecture. The main interface 801 may include an initial request module 803 for the user to input initial requests to the agent, a canvas 805 for rendering and displaying flowcharts 819, etc., and a modification / testing module 809 for receiving user input to modify or test code or flowcharts. The main interface 801 may also include any other suitable or beneficial modules for generating flowcharts. For example, the main interface 801 may include a file management module for code or flowcharts (not shown), etc. In some embodiments, the user can use a selection box 831 to select nodes 823, 825, 827, and 829, etc., in the flowchart displayed on the canvas. If the user discovers potential problems with these nodes during trial operation, they may want to modify these nodes 525, 527, 529, and 531, etc., to ensure the corresponding code is effective or to resolve the discovered problems. In some embodiments, in response to the user completing the node selection, the system's main interface can jump to... Figure 9 .

[0063] In some embodiments, in response to the user completing the node selection, the system's main interface redirects to... Figure 9 .exist Figure 9 The interactive module may include a node modification main interface 901. The node modification main interface 901 may include a node selection module 903 displaying the selected node, and a static text box 905 displaying search information. In some embodiments, the node modification main interface 901 may also include a proxy selection module 907 for selecting a proxy, a system prompt module 909 for displaying system prompts, and a user prompt module 911 for inputting user prompts. In some embodiments, the node modification main interface 901 may also include an input module 913 for inputting parameters, and an output module 915 for displaying the running results of the modified node during debugging. In the node modification main interface 901, the user can select a suitable proxy through the proxy selection module 907, input the corresponding prompts in the user prompt module 911, and input the parameters required for the node in the input module 913. This allows the user to modify problematic nodes and monitor the correctness of the modification results through the output module 915.

[0064] Therefore, when a problem is discovered, the user can select one or more specific related nodes on canvas 805 and enter new modification instructions in dialog boxes such as 911, achieving precise intent-driven modifications and continuous iteration. The agent will make incremental modifications to the one or more nodes based on the existing code, thus repeating the "generate-verify-trace" code or flowchart loop.

[0065] In this way, one or more embodiments of Method 800 and Method 900 provide a novel approach to modifying code and flowcharts. One or more embodiments of Method 800 and Method 900 modify the business logic code, parse the modified code to generate a corresponding modified flowchart, and display the modified flowchart for further user interaction. This achieves automatic flowchart generation and display, enhances user interaction with the flowchart, reduces the difficulty for users to understand the business logic, and significantly improves the user experience. Furthermore, because one or more embodiments of Method 800 and Method 900 provide convenient methods for modifying and testing code and flowcharts, users also significantly reduce product development and maintenance costs and improve work efficiency.

[0066] In summary, the interactive module including a canvas provided by one or more embodiments of this disclosure ensures the visual presentation of flowcharts, etc. Based on a standardized canvas schema generated by a backend agent, it is rendered as a flowchart with a fixed layout and conforming to a logical structure. In some embodiments, the interactive module also provides interaction-driven functionality. For example, it captures user actions on the canvas (such as node clicks, parameter modifications, initiating trial runs, etc.) and converts them into requests to backend services or triggers state changes within the frontend.

[0067] In some embodiments, the canvas-based interactive module provided in one or more embodiments of this disclosure also ensures state synchronization. For example, the interactive module receives and responds to real-time messages from backend services (such as node explanations and trial operation status pushed via SSE / WS), dynamically updates the canvas UI, and ensures consistency between the front-end and back-end states. In some embodiments, the canvas-based interactive module provided in one or more embodiments of this disclosure also provides debugging support for code or flowcharts. For example, it provides a Trace visualization panel to structure and graphically display complex execution logs, assisting users in locating and debugging problems. Furthermore, the interactive module has clear boundaries: it connects upstream to a backend proxy (obtaining schema and real-time status via HTTP / SSE / WS protocols), and downstream it faces the end user (providing a graphical interactive interface). It does not handle business logic generation itself, but focuses on the visual translation and interactive verification of business logic.

[0068] In some embodiments, the interaction module may include a node library. The node library provides a standardized set of process node components (such as start, end, task, condition, loop, etc.), each responsible for rendering its specific UI form. In some embodiments, the interaction module can also manage connection lines. For example, it can automatically draw connection lines between nodes based on the node relationships defined in the schema, and handle states such as highlighting and animation. In some embodiments, the interaction module can also employ a fixed layout strategy. For example, it can use a deterministic layout algorithm (such as FlowGram) to ensure that the same schema always generates the exact same layout, facilitating agent understanding and code or flowchart generation, and fundamentally avoiding the performance overhead of free layout.

[0069] In some embodiments, the interaction module may include an interaction orchestration engine. This engine may include an event model. The event model defines a set of standard user interaction events (e.g., node:click, run:start) and distributes and processes them through a unified event bus. In some embodiments, the interaction orchestration engine can perform state management. For example, it employs a centralized state management mechanism to maintain the global state of the canvas, including node data, connection relationships, running status, user input, etc. All UI changes are state-driven, ensuring unidirectional and predictable data flow. In some embodiments, the interaction orchestration engine can perform action orchestration. For example, it maps user actions to specific actions, such as "request node explanation" or "initiate single-point trial run," and calls the corresponding service interfaces.

[0070] In some embodiments, the interactive module may also employ animation and timing strategies. In some embodiments, the animation and timing strategies may include diff patches. For example, when a new schema is received, a patch set containing create, update, and remove operations is generated by comparing the new schema with the old schema. In some embodiments, diff patches may be applied in a step-by-step manner. For example, operations in the patch set are applied to the canvas in a fixed order of "remove first, then update, then create," and each operation is accompanied by a smooth transition animation (such as fade-in / fade-out, displacement), transforming a one-time data change into a series of ordered visual dynamic effects.

[0071] In some embodiments, one or more embodiments of this disclosure follow a unified data contract based on JSON Schema extensions. The `definition` field defines the parameter structure and type of a node, the `default` field provides default values ​​for the parameters, and the `info` field carries metadata such as integration and status. In some embodiments, one or more embodiments of this disclosure can guarantee accurate data mapping. For example, mapping node data in the schema to corresponding UI components and mapping parameter definitions to form controls in the sidebar enables automatic rendering of data to the view.

[0072] In some embodiments, one or more embodiments of this disclosure also provide runtime preview and trace functionality. For example, a trial run interface is provided, which offers an interactive interface for triggering global or single-node trials and receives running status (such as waiting, running, success, failure) and data in real time via WebSocket, dynamically updating the node UI. In some embodiments, one or more embodiments of this disclosure also provide trace visualization functionality. For example, structured trace data reported by the backend (including node ID, time consumption, input / output snapshots) is rendered into a debug view in timeline or list format, supporting user backtracking and location.

[0073] In some embodiments, one or more embodiments of this disclosure can actively pull schemas via HTTP, receive streaming node interpretation information via SSE, and perform real-time bidirectional communication such as trial runs via WebSocket. In some embodiments, one or more embodiments of this disclosure can also be integrated with a backend proxy. For example, as a "visual frontend" of the backend proxy, the two exchange minimally necessary information through the above-mentioned protocols, achieving observability and controllability of the proxy construction process.

[0074] Therefore, through the detailed description of one or more embodiments of this disclosure above, significant technical effects have been achieved. On one hand, one or more embodiments of this disclosure greatly improve efficiency. For example, an end-to-end closed loop is achieved, shortening the development cycle. A complete closed loop from "natural language orchestration → code generation → canvas verification → runtime tracing → dialogue iteration" is realized, seamlessly integrating the originally scattered development, debugging, and verification stages, significantly shortening the transformation cycle from requirements to a workable product.

[0075] On the other hand, one or more embodiments of this disclosure achieve intelligent information retrieval and optimize the rendering of flowcharts, etc. For example, the front-end adopts a strategy of actively fetching schemas, which can effectively merge multiple consecutive changes from the back-end, avoiding large package transfers and interface redraws caused by frequent full data pushes, making the project execution process more robust and efficient. Furthermore, one or more embodiments of this disclosure ensure the consistency and reuse of information or data. For example, the generated code and the corresponding extended schema serve as a unified data contract between the front-end and back-end. This ensures the consistency of data flow between different system layers and lays the foundation for cross-scenario reuse.

[0076] On the other hand, the methods of one or more embodiments of this disclosure conform to standards and are easy to migrate. For example, standardized product frameworks and code organization specifications enable the generated projects to be exported and run independently in environments without internal dependencies. This facilitates project migration, reuse, and integration with external systems. Furthermore, one or more embodiments of this disclosure, by employing unified node types, input / output structures, and communication protocol conventions, reduce the cognitive burden on developers when switching between different modules and scenarios.

[0077] On the other hand, one or more embodiments of this disclosure provide observability and debugging support for code or flowcharts. For example, it provides two matching debugging modes: node-level trial run and global trial run, making the inputs and outputs of each step in the workflow observable. When an error occurs, it can accurately locate the faulty node and provide clear error information and automatic repair suggestions, greatly improving debugging efficiency.

[0078] On the other hand, one or more embodiments of this disclosure also ensure that trace and interpretation work together to form a diagnostic basis. For example, a separate trace panel supports backtracking of historical operation records and node location, which, combined with the SSE-based real-time node interpretation function, provides developers with a diagnostic basis that can be discussed and reproduced. Furthermore, one or more embodiments of this disclosure also provide a continuous chain of evidence and change tracking. For example, by referencing nodes (tags) in the dialogue and backfilling the context, a continuous chain of evidence from "problem discovery → dialogue modification → change verification" is established, making the intent and result of each iteration clear and traceable.

[0079] On the other hand, one or more embodiments of this disclosure also guarantee stability and performance. For example, the use of a fixed layout fundamentally avoids the performance bottleneck caused by frequent triggering of complex layout algorithms in free layout. Combining virtualized rendering with an incremental update mechanism of "difference patching + step-by-step animation" effectively reduces the rendering cost of large-scale workflows. Furthermore, one or more embodiments of this disclosure also provide multiple mechanisms to enhance fault tolerance. For example, unified WebSocket connection management, built-in error boundaries and automatic reconnection mechanisms, and an HTTP proactive fetch strategy collectively improve the overall stability and network fault tolerance of the system.

[0080] In summary, traditional platforms typically treat the execution process as a "black box," making debugging difficult. One or more embodiments of this disclosure achieve a white-box, observable debugging experience through node-level trial runs and a Trace panel. Furthermore, traditional platforms often employ flexible layouts, making the logical relationships between nodes difficult to understand, requiring additional parsing by both agents and users. One or more embodiments of this disclosure use a fixed layout, resulting in a more intuitive structure, easier agent understanding and generation, and easier maintenance for developers.

[0081] Furthermore, compared to pure code generation, one or more embodiments of this disclosure provide a visual closed loop. For example, pure code generation lacks effective visualization and interactive debugging methods. One or more embodiments of this disclosure provide a visual representation from code to canvas, SSE node explanation, real-time WebSocket trial run, and Trace panel, constructing a complete interactive closed loop of "build-verify". Moreover, one or more embodiments of this disclosure unify communication and context. For example, pure code generation tools typically do not concern themselves with communication protocols and context management. One or more embodiments of this disclosure achieve unified message and state management by reusing the unified WebSocket channel of the IDE and encapsulating the service layer, enabling multi-round iteration and collaborative development.

[0082] Figure 10 A block diagram of an apparatus 1000 for generating flowcharts according to some embodiments of the present disclosure is shown. Figure 10 As shown, the device 1000 includes a generation module 1010 configured to generate code in response to user input for creating code to process transactions. The device 1000 also includes a parsing module 1020 configured to parse the code to generate a flowchart indicating multiple nodes. Furthermore, the device 1000 includes a display module 1030 configured to display the flowchart, wherein at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0083] In some embodiments, the generation module 1010 is further configured to receive user input in natural language for creating code to process transactions, and to generate code via an agent based on the received user input in natural language for creating code to process transactions. In some embodiments, the display module 1030 is further configured to draw the nodes of the flowchart and the connecting lines between the nodes using a predetermined layout algorithm.

[0084] In some embodiments, the apparatus 1000 may further be configured to run a node in response to a user's request to run the node. In some embodiments, running the node in response to a user's request to run the node may include highlighting the running status of the node in response to the running node request. In some embodiments, running the node in response to a user's request to run the node may further include determining a detailed description of the node's running status via an agent in response to a user's request for the node's running status, and displaying a detailed description of the node's running status. In some embodiments, running the node in response to a user's request to run the node may further include at least one of the following: recording the process of running the node; or displaying the recording process in response to a user's access request for the recorded process. In some embodiments, running the node in response to a user's request to run the node may further include receiving user input data in response to a user's request to run the node, running the node based on the user's input data, and displaying output data after running the node in response to the user's request to run the node.

[0085] In some embodiments, the apparatus 1000 may also be configured to, in response to a user's request for at least one of the nodes, receive modifications made by the user to at least one node, and generate modified code based on the user's modifications to at least one node. In some embodiments, generating modified code based on the user's modifications to at least one node may include, based on the user's modifications to at least one node and the code, incrementally modifying the modified at least one node through a proxy to generate the modified code.

[0086] In some embodiments, the parsing module 1020 may further be configured to parse the modified code to generate a modified flowchart. In some embodiments, the display module 1030 may further be configured to display the modified flowchart, wherein the modified flowchart includes at least one modified node. In some embodiments, the display module 1030 may further be configured to compare the flowchart and the modified flowchart, determine the differences between the flowchart and the modified flowchart, and display the modified flowchart based on the determined differences between the flowchart and the modified flowchart. In some embodiments, the generation module 1010 is further configured to generate modified code via a proxy in response to a user's request to modify the code based on natural language. In some embodiments, the flowchart includes JSON data.

[0087] It is understandable that, in this way, one or more embodiments of device 1000 provide a novel approach to modifying code and flowcharts. One or more embodiments of device 1000 modify the business logic code, parse the modified code to generate a corresponding modified flowchart, and display the modified flowchart for further user interaction. This achieves automatic generation and display of flowcharts, enhances user interaction with the flowcharts, reduces the difficulty for users to understand the business logic, and significantly improves the user experience. Furthermore, because one or more embodiments of device 1000 provide convenient methods for modifying and testing code and flowcharts, users also significantly reduce product development and maintenance costs and improve work efficiency.

[0088] Figure 11 A block diagram of a device 1100 capable of implementing various embodiments of the present disclosure is shown. (See diagram for example.) Figure 11 As shown, device 1100 includes a central processing unit (CPU) and / or a graphics processing unit (GPU) 1101, which can perform various appropriate actions and processes according to computer program instructions stored in read-only memory (ROM) 1102 or loaded from storage unit 1108 into random access memory (RAM) 1103. Various programs and data required for the operation of device 1100 can also be stored in RAM 1103. The CPU / GPU 1101, ROM 1102, and RAM 1103 are interconnected via bus 1104. Input / output (I / O) interface 1105 is also connected to bus 1104. Although not shown in... Figure 11 As shown, device 1100 may also include a coprocessor.

[0089] Multiple components in device 1100 are connected to I / O interface 1105, including: input unit 1106, such as keyboard, mouse, etc.; output unit 1107, such as various types of monitors, speakers, etc.; storage unit 1108, such as disk, optical disk, etc.; and communication unit 1109, such as network card, modem, wireless transceiver, etc. Communication unit 1109 allows device 1100 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0090] The various methods or processes described above can be executed by CPU / GPU 1101. For example, in some embodiments, the methods may be implemented as computer software programs tangibly contained in a machine-readable medium, such as storage unit 1108. In some embodiments, part or all of the computer program may be loaded and / or installed on device 1100 via ROM 1102 and / or communication unit 1109. When the computer program is loaded into RAM 1103 and executed by CPU / GPU 1101, one or more steps or actions in the methods or processes described above can be performed.

[0091] In some embodiments, the methods and processes described above can be implemented as a computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of this disclosure.

[0092] Computer-readable storage media can be tangible devices capable of holding and storing instructions for use by an instruction execution device. Computer-readable storage media can be, for example, but not limited to, electrical storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices, such as punch cards or recessed protrusions storing instructions thereon, and any suitable combination thereof. The computer-readable storage media used herein are not to be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses through fiber optic cables), or electrical signals transmitted through wires.

[0093] The computer-readable program instructions described herein can be downloaded from computer-readable storage media to various computing / processing devices, or downloaded via a network, such as the Internet, a local area network (LAN), a wide area network (WAN), and / or a wireless network, to an external computer or external storage device. The network may include copper cables, fiber optic cables, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to the computer-readable storage media in the respective computing / processing device.

[0094] Computer program instructions used to perform the operations of this disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, status setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​and conventional procedural programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry, such as programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), is personalized by utilizing the status information of the computer-readable program instructions to execute the computer-readable program instructions, thereby implementing various aspects of this disclosure.

[0095] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that, when executed by the processing unit of the computer or other programmable data processing apparatus, they create means for implementing the functions / actions specified in one or more blocks of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner. Thus, the computer-readable medium storing the instructions comprises an article of manufacture that includes instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0096] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

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

[0098] This disclosure also provides the following examples:

[0099] Example 1. A method for generating flowcharts, comprising:

[0100] In response to user input regarding creating code to handle transactions, generate code;

[0101] Parse the code to generate a flowchart of the code, the flowchart indicating multiple nodes; and

[0102] Display a flowchart in which at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0103] Example 2. According to the method described in Example 1, wherein in response to user input for creating code to process transactions, generating code includes:

[0104] Receive user input in natural language for creating code to process transactions;

[0105] Based on the received user input in natural language, code is generated through an agent to create code for processing transactions.

[0106] Example 3. The method described in Examples 1-2, wherein the flowchart includes:

[0107] The flowchart nodes and the connecting lines between nodes are drawn using a predefined layout algorithm.

[0108] Example 4. The method described in Examples 1-3 further includes:

[0109] Run the node in response to the user's request to run the node.

[0110] Example 5. According to the method described in Examples 1-4, the running node, in response to a user's request to run a node, includes:

[0111] In response to the running node, highlight the running status of the running node.

[0112] Example 6. According to the method described in Examples 1-5, the method of running the node further includes, in response to a user's request to run the node:

[0113] In response to a user's request for information about the node's operational status, the proxy determines a detailed description of the node's operational status; and

[0114] Displays a detailed description of the node's running status.

[0115] Example 7. The method according to Examples 1-6, wherein in response to a user's request to run a node, running the node further includes at least one of the following:

[0116] Record the process of running the node; or

[0117] In response to a user's access request for the recorded process, the recorded process is displayed.

[0118] Example 8. The method according to Examples 1-7, wherein, in response to a user's request to run a node, running the node further includes:

[0119] In response to user requests to run a node, it receives user input data;

[0120] Run nodes based on user input data; and

[0121] Displays the output data after the node is run.

[0122] Example 9. The method according to Examples 1-8 further includes:

[0123] In response to a user's request for at least one of the nodes, receive modifications made by the user to at least one node; and

[0124] Based on user modifications to at least one node, generate the modified code.

[0125] Example 10. According to the method described in Examples 1-9, the generation of modified code based on user modifications to at least one node includes:

[0126] Based on user modifications to at least one node and the code, an agent performs incremental modifications to the modified node to generate the modified code.

[0127] Example 11. A flowchart for parsing code to generate code, according to the method described in Examples 1-10, includes:

[0128] The modified code is parsed to generate the modified flowchart.

[0129] Example 12. Following the method in Examples 1-11, the flowchart showing the code includes:

[0130] Show the modified flowchart, which includes at least one modified node.

[0131] Example 13. The flowchart showing the code, based on the methods described in Examples 1-12, further includes:

[0132] Compare the original flowchart with the revised flowchart to determine the differences between them; and

[0133] Based on the differences between the established flowchart and the modified flowchart, the modified flowchart is displayed.

[0134] Example 14. According to the method described in Examples 1-13, the generation of code in response to user input for creating code to process transactions further includes:

[0135] In response to a user's request to modify the code based on natural language, the modified code is generated through a proxy.

[0136] Example 15. The method described in Examples 1-14, wherein the flowchart includes JSON data.

[0137] Example 16. An electronic device comprising:

[0138] The generation module is configured to generate code in response to user input for creating code to handle transactions;

[0139] The parsing module is configured to parse code to generate a flowchart, which indicates multiple nodes; and

[0140] The display module is configured to display a flowchart, wherein at least one of the multiple nodes in the displayed flowchart is user-interactive.

[0141] Example 17. The electronic device according to Example 16, wherein in response to user input for creating code for processing transactions, generating code includes:

[0142] Receive user input in natural language for creating code to process transactions;

[0143] Based on the received user input in natural language, code is generated through an agent to create code for processing transactions.

[0144] Example 18. An electronic device according to Examples 1-17, wherein the flowchart includes:

[0145] The flowchart nodes and the connecting lines between nodes are drawn using a predefined layout algorithm.

[0146] Example 19. An electronic device comprising:

[0147] Processor; and

[0148] A memory coupled to a processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to any one of Examples 1 to 15.

[0149] Example 20. A computer program product comprising computer-executable instructions, wherein the computer-executable instructions are executed by a processor to implement the method according to any one of Examples 1 to 15.

[0150] The various embodiments of this disclosure have been described above. These descriptions are exemplary and not exhaustive, nor are they limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principles, practical applications, or technical improvements to the technology in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for generating flowcharts, comprising: The code is generated in response to user input for creating code to handle transactions; The code is parsed to generate a flowchart of the code, the flowchart indicating multiple nodes; as well as The flowchart is displayed, wherein at least one of the plurality of nodes in the displayed flowchart is user-interactive.

2. The method of claim 1, wherein generating the code in response to user input for creating code for processing transactions comprises: Receive input from the user in natural language for creating code to process transactions; Based on the received user input in natural language for creating code to process transactions, the code is generated by an agent.

3. The method of claim 1, wherein displaying the flowchart comprises: The nodes of the flowchart and the connecting lines between the nodes are drawn using a predetermined layout algorithm.

4. The method according to claim 1, further comprising: In response to the user's request to run the node, the node is run.

5. The method of claim 4, wherein running the node in response to the user's request to run the node comprises: In response to the running of the node, highlight the running status of the running node.

6. The method of claim 5, wherein running the node in response to the user's request to run the node further comprises: In response to the user's request for information about the node's running status, a detailed description of the node's running status is determined through the proxy. as well as This displays a detailed description of the node's operating status.

7. The method of claim 4, wherein running the node in response to the user's request to run the node further comprises at least one of the following: Record the process of running the node; or In response to the user's access request for the recorded process, the recorded process is displayed.

8. The method of claim 4, wherein running the node in response to the user's request to run the node further comprises: In response to the user's request to run the node, receive the user's input data; The node is run based on the user's input data; as well as Displays the output data after the node is run.

9. The method of claim 4, further comprising: In response to a user's request for at least one of the nodes, receive the user's modifications to the at least one node; as well as Based on the user's modifications to the at least one node, the modified code is generated.

10. The method of claim 9, wherein generating the modified code based on the user's modification of the at least one node comprises: Based on the user's modifications to the at least one node and the code, an agent performs incremental modifications on the modified at least one node to generate the modified code.

11. The method of claim 9, wherein the flowchart for parsing the code to generate the code comprises: The modified code is parsed to generate the modified flowchart.

12. The method of claim 11, wherein the flowchart displaying the code comprises: The modified flowchart is shown, wherein the modified flowchart includes the modified at least one node.

13. The method of claim 12, wherein the flowchart displaying the code further comprises: Compare the flowchart and the modified flowchart to determine the differences between the two flowcharts; as well as Based on the differences between the determined flowchart and the modified flowchart, the modified flowchart is displayed.

14. The method of claim 1, wherein generating the code in response to user input for creating code for processing transactions further comprises: In response to a user's request to modify the code based on natural language, the modified code is generated through a proxy.

15. The method of claim 1, wherein the flowchart comprises JSON data.

16. An electronic device comprising: A generation module, configured to generate the code in response to user input for creating code to process transactions; A parsing module is configured to parse the code to generate a flowchart of the code, the flowchart indicating multiple nodes; as well as A display module is configured to display the flowchart, wherein at least one of the plurality of nodes in the displayed flowchart is user-interactive.

17. The electronic device of claim 16, wherein generating the code in response to user input for creating code for processing transactions comprises: Receive input from the user in natural language for creating code to process transactions; Based on the received user input in natural language for creating code to process transactions, the code is generated by an agent.

18. The electronic device of claim 16, wherein displaying the flowchart comprises: The nodes of the flowchart and the connecting lines between the nodes are drawn using a predetermined layout algorithm.

19. An electronic device comprising: processor; as well as A memory coupled to the processor, the memory having instructions stored therein, which, when executed by the processor, cause the electronic device to perform the method according to any one of claims 1 to 15.

20. A computer program product comprising computer-executable instructions, wherein the computer-executable instructions are executed by a processor to implement the method according to any one of claims 1 to 15.

Images