An AIGC multi-modal content generation and task linkage method and system based on multi-agent menu arrangement

Abstract

The application discloses an AIGC multi-modal content generation and task linkage method and system based on a multi-agent menu arrangement, relates to the field of generative artificial intelligence models, and comprises the following steps: acquiring an initial generation request of a first multi-modal content in a multi-agent linkage interface, extracting semantic entities of an initial generation product returned by a bottom-layer content generation engine, writing the semantic entities into a context cache area, and generating cross-modal shared data; receiving a flow instruction of a secondary generation node in the multi-agent linkage interface, reading the semantic entities in the cross-modal shared data, and generating a derivative generation request of a second multi-modal content; sending the derivative generation request to a corresponding bottom-layer content generation engine, obtaining a global task number; calculating a task progress; when the task progress reaches a completion state, extracting a derivative generation product returned by the bottom-layer content generation engine, and generating a target result file. The application can save model resource consumption.

Description

Technical Field

[0001] This application relates to the field of generative artificial intelligence models, and in particular to a method and system for AIGC multimodal content generation and task linkage based on multi-agent menu arrangement. Background Technology

[0002] With the increasing adoption of generative artificial intelligence technology in education, marketing, and office presentations, the demand for multimodal content generation is growing. Business scenarios typically require the production of composite content encompassing multiple modalities such as text, images, audio, and video. Examples include micro-lesson videos composed of presentation slides, instructor voice, and digital human visuals, to meet diverse information display needs.

[0003] In related technologies, multimodal content generation systems adopt a microservice architecture, encapsulating different content generation capabilities into independent service modules and providing a navigation menu with multiple fixed functional entry points on the front end. When generating composite video courses, the system receives the topic content through the presentation generation entry point, processes it, and downloads the generated presentation file to the local machine. Subsequently, the system receives the re-uploaded presentation file through the digital human video generation entry point, and on this page, it receives configuration instructions for the digital human image, voice parameters, and lecture text. It then initiates periodic Hypertext Transfer Protocol polling requests to different underlying interfaces to obtain the execution status of each task and update the progress bar of the corresponding page.

[0004] However, under the demand for highly integrated and coherent multimodal content production, the related technologies adopt independent service modules and periodic polling flow methods. When cross-modal context information transmission is interrupted or multiple concurrent task states are synchronized, there will be a problem of rapid consumption of model resources. Summary of the Invention

[0005] This application provides a method and system for AIGC multimodal content generation and task linkage based on multi-agent menu arrangement, which can save model resource consumption.

[0006] Firstly, this application provides an AIGC multimodal content generation and task linkage method based on multi-agent menu orchestration, applied to an intelligent interactive system. The method includes: obtaining an initial generation request for the first segment of multimodal content in a multi-agent linkage interface, and sending the initial generation request to a lower-level content generation engine; extracting the semantic entities of the initial generation products returned by the lower-level content generation engine, writing the semantic entities into a context cache, and generating cross-modal shared data; receiving flow instructions from secondary generation nodes in the multi-agent linkage interface, reading the semantic entities from the cross-modal shared data to fill the configuration parameters of the secondary segment of multimodal content, and generating a derived generation request for the secondary segment of multimodal content; sending the derived generation request to the corresponding lower-level content generation engine to obtain a global task number; extracting the original state data of the lower-level content generation engine associated with the global task number and pushing it to the multi-agent linkage interface to calculate the task progress; and when the task progress reaches the completion state, extracting the derived generation products returned by the lower-level content generation engine, and generating a target result file based on the initial generation products and the derived generation products.

[0007] In the above embodiments, the intelligent interaction system establishes a context cache area to extract and store the core semantic information in the output (initial generated product) of the first generation task in a structured manner, forming cross-modal shared data that can be directly called by subsequent tasks. This enables different stages of multimodal content generation to be effectively linked, and subsequent generation steps do not need to repeatedly parse the original file or request redundant information. They can be started directly using the shared data, which reduces repeated calls to the underlying generation engine, reduces the consumption of computing resources, and improves the coherence and efficiency of multi-step content generation.

[0008] In conjunction with some embodiments of the first aspect, in some embodiments, the step of extracting the semantic entities of the initial generated product returned by the underlying content generation engine, writing the semantic entities into the context cache, and generating cross-modal shared data specifically includes: extracting the structural boundary identifier of the initial generated product returned by the underlying content generation engine; performing a segmentation operation on the initial generated product according to the structural boundary identifier to obtain segmented semantic entities; and writing the segmented semantic entities and the structural boundary identifier into the context cache to generate cross-modal shared data.

[0009] In the above embodiments, the intelligent interactive system achieves automated and structured content segmentation by recognizing structural boundary identifiers (such as page separators) of the initial generated output (such as a PPT file). This approach decomposes the originally unified content into multiple independent and context-related segmented semantic entities (such as the content of each PPT page), facilitating refined operations (such as generating lecture notes page by page and allocating timelines), and making the mapping and alignment of cross-modal content more accurate and efficient.

[0010] In conjunction with some embodiments of the first aspect, in some embodiments, after the step of writing segmented semantic entities and structural boundary identifiers into the context buffer to generate cross-modal shared data, the method further includes: reading segmented semantic entities and structural boundary identifiers from the cross-modal shared data; extracting preset time axis allocation rules from the secondary generation nodes; mapping segmented semantic entities to corresponding time axis intervals according to the structural boundary identifiers and time axis allocation rules to obtain time alignment parameters; and writing the time alignment parameters into the configuration parameters of the secondary multimodal content to generate a derived generation request.

[0011] In the above embodiments, the intelligent interaction system uses structural boundary identifiers and preset time axis allocation rules to automatically map disordered semantic entities onto the time axis; for example, it automatically assigns an initial playback duration to each page of PPT content, avoiding the problem of content and time being difficult to automatically match when generating multimodal content such as videos, and providing precise time control parameters for generating time-related derivative content such as audio and video, thus realizing the automatic synchronization of content and time.

[0012] In conjunction with some embodiments of the first aspect, in some embodiments, before the steps of reading semantic entities in cross-modal shared data to fill configuration parameters of secondary multimodal content and generating a derived generation request for secondary multimodal content, the method further includes: extracting background attribute features from the initial generation product and extracting foreground attribute features from the configuration parameters; calculating the feature overlap between the background attribute features and the foreground attribute features; and updating the foreground attribute features in the configuration parameters when the feature overlap is higher than a preset conflict threshold.

[0013] In the above embodiments, the intelligent interaction system actively performs conflict detection of attribute features before synthesizing content of different modalities. For example, when superimposing a digital human onto a PPT background, it detects the similarity between the color of the digital human's clothing and the color of the PPT background. When it detects that the feature overlap is too high (i.e., a conflict may occur), the system updates the foreground attributes (such as adjusting the color of the digital human's clothing), avoiding visual confusion or information occlusion in the final generated content, and improving the final presentation quality and usability of the multimodal synthesis product.

[0014] In conjunction with some embodiments of the first aspect, in some embodiments, after the steps of extracting the derived generated products returned by the underlying content generation engine and generating a target result file based on the initial generated products and the derived generated products when the task progress reaches the completion state, the method further includes: receiving a modification instruction sent by a multi-agent linkage interface to determine the updated semantic entity; determining the modified data segment based on the updated semantic entity and the semantic entity in the context cache; sending the modified data segment to the corresponding underlying content generation engine to obtain the local derived generated product; extracting the current duration value of the local derived generated product and extracting the historical duration value corresponding to the modified data segment to calculate the time offset value; and writing the time offset value and the local derived generated product into the context cache.

[0015] In the above embodiments, the intelligent interaction system supports partial modification of generated content, rather than global regeneration; when a user modifies part of the content, the system only sends the modified data segment to the engine for processing and calculates the duration difference between the old and new content; this reduces the amount of computation and time cost required for modification operations, especially for large multimodal files such as long videos, avoiding unnecessary repeated rendering and achieving efficient and accurate incremental updates.

[0016] In conjunction with some embodiments of the first aspect, in some embodiments, after writing the time offset value and the locally derived generated product into the context buffer, the method further includes: extracting the target position index of the modified data segment in the target result file; replacing the historical generated product corresponding to the historical duration value with the locally derived generated product; extracting the subsequent generated product located after the locally derived generated product in the target result file according to the target position index; extracting the timestamp parameter of the subsequent generated product, and superimposing the time offset value into the timestamp parameter to obtain the translation timestamp parameter; updating the arrangement position of the subsequent generated product in the target result file based on the translation timestamp parameter to obtain the updated result file.

[0017] In the above embodiments, after the intelligent interactive system completes the replacement of partial content, it uses the calculated time offset value to automatically adjust the timestamps of all subsequent content. This ensures that after modifying some content (such as a speech) and causing a change in duration, the temporal relationship of the entire video can be automatically rearranged and remain coherent. This avoids the tedious work of manually adjusting all subsequent segments and ensures the audio-visual synchronization and smooth playback of the final output file.

[0018] In conjunction with some embodiments of the first aspect, in some embodiments, the step of extracting the raw state data of the underlying content generation engine associated with the global task number and pushing it to the multi-agent linkage interface to calculate the task progress specifically includes: extracting the engine type identifier of the underlying content generation engine and reading the estimated time value corresponding to the engine type identifier; determining the initial polling interval length corresponding to the estimated time value and sending a status query request to the underlying content generation engine according to the initial polling interval length; receiving the raw state data returned by the underlying content generation engine and determining the current progress value in the raw state data; when the current progress value is less than a preset progress threshold, increasing the initial polling interval length by a preset step size to obtain a corrected polling interval length; sending the next status query request according to the corrected polling interval length and pushing the current progress value as the task progress to the multi-agent linkage interface.

[0019] In the above embodiments, the intelligent interaction system adopts an adaptive dynamic polling strategy to query the task status. An initial polling interval is determined based on the estimated time consumption of the engine type. When the query finds that the task progress has not yet reached the final stage, the polling interval is gradually increased to reduce invalid queries. When the task progress exceeds the preset progress threshold and enters the final stage, the polling interval is shortened to capture the completion status more promptly. This balances the timeliness of status updates with the server load pressure, avoids a large number of invalid polling requests during the main task processing, and saves network and backend service resources.

[0020] In a second aspect, embodiments of this application provide an intelligent interactive system, which includes: one or more processors and a memory; the memory is coupled to the one or more processors, and the memory is used to store computer program code, which includes computer instructions, and the one or more processors call the computer instructions to cause the intelligent interactive system to perform the method described in the first aspect and any possible implementation thereof.

[0021] Thirdly, embodiments of this application provide a computer-readable storage medium including instructions that, when executed on an intelligent interactive system, cause the intelligent interactive system to perform the method described in the first aspect and any possible implementation thereof.

[0022] Fourthly, embodiments of this application provide a computer program product containing instructions that, when the computer program product is run on an intelligent interactive system, cause the intelligent interactive system to execute the method described in the first aspect and any possible implementation thereof.

[0023] Understandably, the intelligent interactive system provided in the second aspect, the computer storage medium provided in the third aspect, and the computer program product provided in the fourth aspect are all used to execute the methods provided in the embodiments of this application. Therefore, the beneficial effects they can achieve can be referred to the beneficial effects in the corresponding methods, and will not be repeated here.

[0024] One or more technical solutions provided in the embodiments of this application have at least the following technical effects or advantages:

[0025] 1. By adopting a technical solution of setting up a context cache between multimodal content generation tasks and writing the semantic entities of the initial generated products into it to form cross-modal shared data, subsequent derivative generation requests can directly read the shared data for filling. This effectively solves the problem in the existing technology that the cross-modal context information transmission is broken, which leads to the need to repeatedly parse the original material or request redundant information in the subsequent generation stage. This achieves seamless linkage between different generation nodes and saves model resource consumption.

[0026] 2. By adopting a technical solution that extracts the background attribute features of the initial generated product and the foreground attribute features of the configuration parameters before compositing the content, calculates the feature overlap, and updates the foreground attribute features when the overlap exceeds the conflict threshold, the system can identify and avoid visual conflicts between different modal elements in advance. This effectively solves the problem of information occlusion or poor visual effects that may be caused by directly superimposing content in the existing technology, thereby achieving an automated improvement in the quality of multimodal content synthesis.

[0027] 3. Because the system adopts a technical solution that sends only the modified data segment to the engine to generate local derivative products after receiving the modification instruction, and calculates the time offset between the old and new products, the system does not need to reprocess the entire task when updating content. This effectively solves the problem of resource waste and excessive time consumption caused by global regeneration when modifying local content in the existing technology, thus realizing efficient incremental editing and updating of multimodal content. Attached Figure Description

[0028] Figure 1 This is a flowchart illustrating the AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement in this application embodiment;

[0029] Figure 2 This is another flowchart illustrating the AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement in this application embodiment;

[0030] Figure 3 This is a schematic diagram of the physical device structure of an intelligent interactive system in the embodiments of this application. Detailed Implementation

[0031] The terminology used in the following embodiments of this application is for the purpose of describing particular embodiments only and is not intended to be limiting of this application. As used in the specification of this application, the singular expressions “a,” “an,” “the,” “the,” and “this” are intended to include the plural expressions as well, unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used in this application refers to any or all possible combinations including one or more of the listed items.

[0032] Hereinafter, the terms "first" and "second" are used for descriptive purposes only and should not be construed as implying or suggesting relative importance or implicitly indicating the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature, and in the description of the embodiments of this application, unless otherwise stated, "multiple" means two or more.

[0033] In the specific implementation scenario of this application, a series of technical terms and proper nouns are involved, and their processing logic and interrelationships are crucial to understanding this technical solution. This solution is mainly applied to a working platform that integrates multiple AIGC (generative artificial intelligence) capabilities, such as for rapidly generating micro-lesson videos.

[0034] In this scenario, the multi-agent linkage interface is the front-end interface for user operation. This interface integrates multiple functional modules such as PPT agent and digital human agent in the form of a menu. Users can initiate a coherent multimodal content generation task through this interface.

[0035] For example, a user first uploads a presentation file using the PPT agent, which constitutes the initial request for generating the first piece of multimodal content. This request is sent to the underlying content generation engine, which is a collective term for a series of specialized AIGC services in the background, such as PPT slicing services and text extraction services. After processing, the engine returns the initial generated output, such as a set of PPT page images and the extracted page text.

[0036] At this point, semantic entities refer to the core information with clear meaning in this set of images and text, such as the title, body text, and image URLs of each page. These semantic entities are written to the context cache, a temporary data structure used to share data between different generation steps.

[0037] When the user proceeds to the next step, such as selecting to generate a digital human narration video, a flow instruction for the secondary generation node is issued. The system reads semantic entities (such as page text) from the context cache to automatically populate the configuration parameters of the secondary multimodal content (such as the script for the digital human video), thereby generating a derivative generation request and calling the corresponding underlying engine (such as the TTS speech synthesis engine and video synthesis engine) again to complete the subsequent tasks.

[0038] The entire process is tracked through a unified global task number, enabling seamless connection and data sharing across modal tasks.

[0039] The method provided in this embodiment is described in detail below. Please refer to [link / reference]. Figure 1 This is a flowchart illustrating an AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement in an embodiment of this application.

[0040] S101. Obtain the initial generation request of the first segment of multimodal content in the multi-agent linkage interface, and send the initial generation request to the underlying content generation engine.

[0041] The multi-agent interactive interface refers to a user interface that integrates multiple AIGC functional modules (agents), such as a front-end application with menu items for PPT generation and digital human video generation. The initial generation request for the first multimodal content indicates the first generation step initiated by the user, such as uploading a document to generate a presentation outline. The underlying content generation engine refers to the back-end service cluster responsible for executing specific generation tasks. Each engine corresponds to one or more AIGC capabilities, such as a large language model engine for generating text and an image generation engine for creating images.

[0042] Specifically, this step is performed at the beginning of a multimodal content creation workflow. The user selects an initial agent in the multi-agent interaction interface, such as a micro-lesson video agent, and provides initial input, such as uploading a PPT format courseware file. This operation is parsed by the system as an initial generation request. This request contains the user's intent (to generate a micro-lesson video), the original materials (PPT file), and possible initial configurations. The intelligent interaction system then routes and sends this request to a matching underlying content generation engine, such as a service specifically designed for processing PPT files, to initiate the first stage of content generation.

[0043] In some embodiments, the initial generation request can be obtained and sent in several ways: Optionally, the user can operate through a graphical interface, click the upload file button in a web page or desktop application, select a local file, and the front end encapsulates the file data and parameters such as task type into an HTTP POST request, which is then sent to the backend gateway, and the gateway distributes it to the corresponding PPT parsing engine. Optionally, the user can enter a command similar to " / create_microcoursefrom_file:path / to / file.pptx" through a text command interface. The command line parser recognizes the command and parameters, constructs an API call request, and sends it to the underlying content generation engine. It is understood that the initial request can also be obtained by dragging and dropping files to a specified area, or by importing files from other applications through plugins, etc., and this is not limited here.

[0044] In some embodiments, the initial generation request may contain files with diverse formats or non-standard content. To address this, the intelligent interaction system adds a preprocessing step before sending the request to the underlying content generation engine. This preprocessing step first detects the file type; for non-standard formats (such as Keynote files), it attempts to convert them to a standard format (such as PPTX) using a file format conversion service. Secondly, it performs preliminary verification of the file content, such as detecting encryption, macro viruses, or severe format corruption, and provides prompts to the user or attempts to automatically repair it, thereby improving the success rate of subsequent processing by the underlying content generation engine.

[0045] S102. Extract the semantic entities of the initial generated products returned by the underlying content generation engine, write the semantic entities into the context cache, and generate cross-modal shared data.

[0046] The initial generated output refers to the result returned by the underlying content generation engine after completing the first stage of the task, such as the images and extracted text of each slide obtained after parsing a PPT file. Semantic entities refer to data units with structured meaning in the output, such as title text, body paragraphs, and image URLs. The context cache is a temporary storage mechanism used to store these semantic entities so that they can be called in subsequent generation steps.

[0047] Specifically, after the underlying content generation engine processes the request in step S101, the intelligent interaction system receives the returned data. For example, the PPT parsing engine returns a JSON array containing multiple sets of data objects, each representing a slide and containing information such as the image URL, extracted text content, and page number. The intelligent interaction system iterates through this array, extracting each data object as one or more semantic entities and assigning a unique identifier to each entity. Subsequently, these semantic entities carrying identifiers are stored in a context cache associated with the current generation session, forming cross-modal shared data that can be used in subsequent steps.

[0048] For semantic entity extraction, the specific process can be as follows: After the underlying content generation engine (e.g., a PPT parsing service) completes its processing, the returned result is typically a structured data object conforming to a predefined data contract, such as a JSON-formatted HTTP response body. The semantic entity extraction module in the intelligent interaction system first deserializes and parses this response body, converting it into a data object in memory. The top layer of this data object is an ordered array, where each element corresponds to a logical unit of the initial generated product (e.g., a page of a PPT). The extraction module then iterates through this array, performing field mapping operations on each element: reading predefined key fields from the element, including but not limited to the page number field (as the location identifier of the semantic entity), the text content field (containing the extracted title and body text of the page), and the media resource field (containing the accessible URLs of the images rendered on the page). The extraction module generates a semantic entity object for each iterated element. The data structure of this object includes a unique entity identifier assigned by the system, the values ​​of the extracted key fields, and a metadata tag marking its source task and modal type. Taking a 5-page PowerPoint presentation as an example, the underlying engine returns a JSON array containing 5 elements. The extraction module will then generate 5 semantic entity objects, each carrying text and image information from its respective page. These 5 semantic entity objects are subsequently organized into an ordered set, using the unique session identifier of the currently generated session as the key, and written to the context cache. In this embodiment, the context cache is implemented as a front-end application-level state management storage structure. Internally, it organizes data in key-value pairs, where the key is the session identifier and the value is the ordered set. This allows subsequent steps to directly read these semantic entities using the same session identifier without needing to request the underlying engine again or re-parse the original file.

[0049] In some embodiments, semantic entity extraction and storage can be implemented in several ways: Optionally, a rule-based extraction method can be used. For known initial generated product data structures (such as the fixed return format of a PPT parsing interface), a parser can be written to directly extract data by field and store it in the state management library of the front-end application (such as Redux or Vuex). Optionally, a model-based extraction method can be used. For unstructured initial products (such as a long article), a natural language processing model can be called to identify semantic entities such as chapters, titles, and paragraphs. Then, these identified entities and their relationships can be stored in a key-value database (such as Redis), using the session ID as the primary key. It is understood that other methods can also be used, such as storing the data in the browser's IndexedDB to support offline operations; this is not limited here.

[0050] In some embodiments, there may be hierarchical or relational relationships between semantic entities in the initial generated output, but these relationships may be lost after being simply written to the cache. To address this, the intelligent interaction system saves the structural information between these entities when writing to the context cache. For example, when parsing a PPT outline, it not only saves the text of each heading but also its hierarchy (e.g., first-level headings, second-level headings) and parent-child relationships (e.g., which second-level heading belongs to which first-level heading). Thus, when generating cross-modal shared data, the data itself contains a tree-like or graph-like structure, facilitating logical calls in subsequent steps, such as organizing content in the correct chapter order when generating a video.

[0051] S103. Receive the flow instructions from the secondary generation node in the multi-agent linkage interface, read the semantic entities in the cross-modal shared data to fill the configuration parameters of the secondary multimodal content, and generate the derivative generation request of the secondary multimodal content.

[0052] In this context, a secondary generation node refers to the second or subsequent step in the multimodal content generation process, such as generating a digital human video after generating a PPT outline. A flow instruction is an operation triggered by the user on the interface to confirm entry into the next generation stage. Configuration parameters are the set of input information required to activate a secondary generation node, such as the script and digital human avatar needed to generate the video.

[0053] Specifically, after previewing the initial deliverables (such as PPT slides and preliminary scripts) generated in step S102 on the multi-agent interaction interface, the user may click the "Generate Explanation Video" button, which is the flow instruction. Upon receiving this instruction, the intelligent interaction system loads the configuration interface for digital human video generation. At this time, the system automatically reads cross-modal shared data from the context cache; for example, it automatically fills the script input box in the video configuration interface with the previously extracted PPT page text. The user can modify these pre-filled contents and set other configuration parameters (such as selecting the digital human image and background music). After confirmation, the system combines these parameters into a derived generation request.

[0054] In some embodiments, parameter filling and derivative request generation can be implemented in several ways: Optionally, a front-end data binding mechanism can be used to bind the values ​​of each input component (such as text boxes and drop-down menus) in the configuration interface of the secondary generation node to specific data fields in the context cache in a two-way or one-way manner to achieve automatic filling. When the user submits, the front-end framework automatically collects the current values ​​of all components and assembles them into a JSON object as the derivative request body. Optionally, a template replacement mechanism can be used to predefine a template for the derivative request, which includes placeholders (such as {script_content}). When a flow instruction is received, the system reads data from the cache, replaces the placeholders in the template, and generates the final request content. It is understood that other methods can also be used, such as using a visual process orchestration tool, where users can manually drag and drop lines to connect the output of the previous node to the input of the next node, defining the data flow logic; this is not limited here.

[0055] In some embodiments, there may be a mismatch between the semantic entity format in the context buffer and the configuration parameter format required by the secondary generation node. To address this, the intelligent interaction system adds a data mapping and conversion layer between reading and filling. This layer maintains a set of mapping rules that define how to convert semantic entities from different sources (such as extracted text from PPT or paragraphs from Word documents) into the standard format required by a specific secondary node (such as the timestamped subtitle format required by the video generation interface). When the system reads data, it first processes it through this conversion layer to ensure that the data format filled into the configuration parameters is correct.

[0056] S104. Send the derived generation request to the corresponding underlying content generation engine to obtain the global task number.

[0057] The underlying content generation engine refers to the backend AIGC service responsible for processing this derived request, such as a video compositing service or a speech cloning service. The global task number is a unique identifier used to track this macro-task, which comprises multiple subtasks, throughout the entire multimodal generation lifecycle.

[0058] Specifically, after the user confirms and submits the configuration parameters of the secondary generation node, the intelligent interaction system sends the derived generation request generated in step S103 to the designated backend API endpoint via the network. For example, a request containing parameters such as the speech text, digital human avatar ID, and voice ID is sent to the " / api / v1 / digital-human / generate" interface. Upon receiving the request, the backend creates a new generation task and immediately returns a global task ID to the frontend. This ID serves as the unique credential for subsequently querying the task status and retrieving results.

[0059] In some embodiments, the sending of requests and the retrieval of task numbers can be achieved in several ways: Optionally, a standard HTTP client library (such as Axios) can be used to send the derived request as the body of a POST request, and the global task number can be parsed from a specific field (such as taskId or job_id) in the response body. Optionally, if the backend uses WebSocket communication, the frontend will send a JSON message containing request parameters through the established WebSocket connection, and the backend will process it and push back an acknowledgment message containing the global task number through the same connection. It is understood that asynchronous communication modes such as message queues can also be used, whereby the frontend sends the task request to a specific topic in the message queue, and the backend consumer processes it and writes the task number back to a database that the frontend can query; this is not limited here.

[0060] In some embodiments, network fluctuations or momentary unavailability of backend services may cause requests to fail to be sent. To address this, the intelligent interaction system implements a request retry mechanism. When the frontend sends a request, if no successful response or a network error code (such as 503 Service Unavailable) is received within a preset timeout period, the system will not immediately report the failure to the user. Instead, it will automatically retry several times, with an exponential backoff strategy increasing the waiting interval between each retry. Only after reaching the maximum number of retries and still failing will the system finally confirm the task submission failure and display the corresponding prompt message to the user.

[0061] S105. Extract the raw state data of the underlying content generation engine associated with the global task number and push it to the multi-agent linkage interface to calculate the task progress.

[0062] The raw status data is the raw information returned by the underlying content generation engine that describes the current execution status of the task. It can include status strings such as processing, done, and failed, as well as a progress percentage value.

[0063] Specifically, after obtaining the global task ID, the intelligent interaction system initiates a polling mechanism, calling the task status query interface (e.g., GET / api / v1 / digital-human / generate / {taskId}) at regular intervals, carrying the task ID. Each query returns the task's raw status data to the backend. Upon receiving the data, the frontend parses and normalizes it, mapping "processing" and "running" to the "processing" status, and "done" and "SUCCESS" to the "completed" status. It also extracts the progress percentage. Finally, this normalized status and progress information is updated in the task management pop-up or progress bar of the multi-agent interaction interface.

[0064] In some embodiments, task progress retrieval and push can be implemented in several ways: Optionally, HTTP short polling can be used, with the frontend using the `setInterval` function to periodically send HTTP GET requests to query the status and update the UI in the callback function. Optionally, Server-Sent Events (SSE) can be used, where the frontend establishes a persistent SSE connection with the server. When the task status changes, the server actively pushes updated data to this connection, and the frontend can receive and update the UI by listening for message events. This method is more efficient than polling. It is understandable that a WebSocket long connection could also be used, with the server actively pushing messages when the status changes to achieve real-time updates; this is not limited here.

[0065] In some embodiments, a global task may contain multiple parallel or sequential subtasks, but the underlying engine only returns the status of a single subtask, making it difficult for the front-end to accurately display the overall progress. To address this, the intelligent interaction system maintains a task dependency graph on the front-end. When a task is initiated, the front-end, based on business logic, knows which subtasks the global task includes and their dependencies. During each polling cycle, the front-end queries the status of all active subtasks and dynamically calculates the overall progress of the global task based on preset weights (such as estimated time) and dependencies. For example, in a micro-lesson video generation task, PPT slicing accounts for 20% of the weight, audio synthesis accounts for 30%, and video synthesis accounts for 50%.

[0066] S106. When the task progress reaches the completion state, extract the derived generated products returned by the underlying content generation engine, and generate the target result file based on the initial generated products and the derived generated products.

[0067] Among them, the derived products are the core results produced after the secondary generation node is successfully executed, such as the synthesized digital human narration video file.

[0068] Specifically, when the polled or pushed status information indicates that the task has been successfully completed, the intelligent interaction system will stop querying. At this time, the data returned by the status query interface usually includes the address of the derived output, such as the download URL of a video file. The system extracts this URL. Depending on business needs, the final target result file can be this video file itself. Further processing may also be required. For example, in a scenario of converting a PPT to a video and adding a cover, the initial output is the image of the first page of the PPT (as the cover), and the derived output is the video explaining the subsequent pages. The system needs to package the cover image and video file into a compressed file as the final target result file and provide it to the user for download. This download interface can be represented by a URL or a QR code for easy information transmission.

[0069] It's important to note that generating the target result file is not simply a file packaging process, but rather a multimodal content synthesis process based on temporal alignment parameters. After confirming that all subtasks have reached completion, the intelligent interactive system reads complete content arrangement data from the context cache. This data includes the temporal alignment parameters (start and end times) for each segment's semantic entity, the corresponding initial generated product resource address (such as the URLs of rendered images for each PPT slide), and the corresponding derived generated product resource addresses (such as the URLs of the synthesized audio files and digital human video clips). The system assembles this data into a synthesis instruction description file. This description file uses the timeline as its main thread, defining the content that should be presented on each track (video track, audio track, and subtitle track) within each time interval and their overlay relationships. For example, within the time interval [0s, 30s], the bottom layer of the video track contains the first PPT slide image, the lower right corner of the top layer of the video track contains the first segment of the digital human video clip, and the audio track contains the first segment of the corresponding TS audio. The system sends the compositing instruction description file to a video compositing engine (which can be implemented based on open-source multimedia processing frameworks such as FFmpeg). The engine then executes operations such as image sequence framing, audio and video mixing, picture-in-picture overlay, and subtitle burning according to the instructions in the description file, and finally outputs a single, independently playable video file as the target result file.

[0070] In some embodiments, the extraction of products and the generation of result files can be achieved in several ways: Optionally, the frontend directly obtains the URL of the result file from the task completion response and displays it on the download button on the interface. The user clicks the button, and the browser initiates the download directly. Optionally, if multiple products need to be combined, the frontend sends a list of URLs for each product to a new backend packaging interface. The backend downloads these files, compresses them into a zip package, and returns the download address of the zip package to the frontend. It is understood that for some small files, the backend can also directly return the file content in Base64 encoded form to the frontend, which then decodes it locally and generates a downloadable file object; this is not limited here.

[0071] In some embodiments, there may be situations where the derived products need to be complexly composited with the initial products. To address this, the intelligent interactive system invokes a dedicated post-production compositing engine. For example, when generating a picture-in-picture effect micro-lesson video, the initial product is a sequence of PPT slide images, and the derived product is a video of a digital human lecturing (with a transparent background). After the task is completed, the system does not directly return these two products; instead, it sends their addresses to a video compositing engine. This engine uses tools such as FFmpeg to overlay the digital human video onto the lower right corner of the PPT slide sequence, generating a single target video file.

[0072] The process described in the above embodiments mainly illustrates a linear flow from initial generation to final delivery. However, in practical applications, users often have further modification needs after content generation and have higher requirements for task execution efficiency and resource consumption. If the entire generation process needs to be re-executed for every minor modification, it will lead to serious resource waste and long waiting times. Therefore, subsequent embodiments, based on the above embodiments, further introduce an incremental modification mechanism for generated content and a more intelligent task status monitoring strategy to solve the above problems and improve the system's flexibility and efficiency.

[0073] The method provided in this embodiment will now be described in more detail. Please refer to [link / reference]. Figure 2 This is another flowchart illustrating the AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement in this application embodiment.

[0074] S201. Obtain the initial generation request of the first segment of multimodal content in the multi-agent linkage interface, and send the initial generation request to the underlying content generation engine.

[0075] Refer to step S101, which will not be repeated here.

[0076] S202. Extracting the semantic entities of the initial generation product returned by the underlying content generation engine, writing the semantic entities into the context buffer, and generating cross-modal shared data.

[0077] Reference is made to step S102, and details are not repeated herein.

[0078] To achieve accurate generation of multi-modal content, in some embodiments, the intelligent interaction system may perform structured segmentation on the initial generation product, that is, the intelligent interaction system extracts the structure boundary identifier of the initial generation product returned by the underlying content generation engine; performs a segmentation operation on the initial generation product according to the structure boundary identifier to obtain segmented semantic entities; and writes the segmented semantic entities and the structure boundary identifier into the context buffer to generate cross-modal shared data.

[0079] The structure boundary identifier refers to specific information that can mark the separation of content structures in the initial generation product, for example, in a PPT file, the end of each page is a boundary identifier; in a Markdown document, each level-1 or level-2 heading can be regarded as a boundary identifier. The segmented semantic entity refers to an independent content block obtained after segmentation according to the boundary identifier, such as the content of a single PPT page or the text of a chapter.

[0080] Specifically, after the underlying content generation engine returns the initial generation product, such as an array containing all PPT page information, the intelligent interaction system traverses the array. For each element in the array (representing one PPT page), the system regards it as a segmented semantic entity. The page number of this page or its index in the array is regarded as the structure boundary identifier. The system writes the content of each page (such as the extracted text and the included image URL) together with its boundary identifier (page number) as an integral object into the context buffer. In this way, the originally continuous PPT content is decomposed into a set of ordered, independently addressable segmented semantic entities.

[0081] In some embodiments, this step can be implemented in various manners: optionally, for products in markup language formats such as XML or HTML, a DOM parser is used to locate the structure boundary identifier and extract the segmented semantic entities through XPath or CSS selectors (such as / / section or h2). Optionally, for plain text documents, regular expressions are used to match chapter headings (such as "^Chapter.*") as boundary identifiers, so as to segment the text into segmented semantic entities of multiple chapters. It can be understood that the generation engine may also directly output in a structured manner when generating the initial product, with boundary identifiers and segmented content embedded in advance, and the front end only needs to perform direct parsing, which is not limited herein.

[0082] In some embodiments, structural boundary identifiers may be ambiguous or missing, such as when a user uploads a long image containing a large amount of text. In response, the intelligent interaction system invokes a visual layout analysis model (a specialized AI model) to handle this. This model can identify visual elements in the image, such as text blocks, titles, and lists, and infer the logical structure of the content based on their spatial location and font size, thereby virtually generating structural boundary identifiers and segmented semantic entities. For example, spatially distant text blocks with large fonts are identified as titles, and these are used as boundaries for segmentation.

[0083] S203. Receive the flow instructions from the secondary generation node in the multi-agent linkage interface, read the semantic entities in the cross-modal shared data to fill the configuration parameters of the secondary multimodal content, and generate the derivative generation request of the secondary multimodal content.

[0084] Refer to step S103, which will not be repeated here.

[0085] In some embodiments, the intelligent interaction system aligns the segmented semantic entities with the timeline. Specifically, the intelligent interaction system reads the segmented semantic entities and structural boundary identifiers from the cross-modal shared data; extracts the preset timeline allocation rules from the secondary generation nodes; maps the segmented semantic entities to the corresponding timeline intervals according to the structural boundary identifiers and the timeline allocation rules to obtain the timeline alignment parameters; and writes the timeline alignment parameters into the configuration parameters of the secondary multimodal content to generate a derived generation request.

[0086] The timeline allocation rule refers to the strategy of mapping content to time, such as playing each PPT slide for 15 seconds or calculating the duration based on the number of words per page, or 200 words per minute. The timeline interval refers to the specific time period allocated to a certain segment semantic entity within the total duration, such as [00:10, 00:25].

[0087] Specifically, when entering secondary generation nodes requiring a time dimension, such as video generation, the intelligent interaction system reads the segmented semantic entities and boundary identifiers stored in the cache. Simultaneously, the system loads preset or user-selected timeline allocation rules. For example, the rule might be to calculate duration based on word count. The system iterates through each segmented semantic entity (such as each slide of a PPT presentation), counts its word count, and calculates the required presentation time for that slide according to the rules. Then, the system accumulates these durations, assigning a start and end time to each slide to form a timeline interval. These timing alignment parameters are ultimately written into the derived generation request, guiding the video compositing engine's operation.

[0088] It should be noted that the timeline allocation rule itself is a parameterized strategy object stored in the secondary generation node configuration. Its core parameters include the base reading rate (e.g., in words per minute, with a default value of 200 words / minute) and the minimum segment duration (e.g., 5 seconds, to ensure that even pages with very little content have a minimum display duration). After the system reads all segmented semantic entities in the cross-modal shared data, the mapping process performs calculations for each segmented semantic entity sequentially according to the following logic: First, the system extracts all characters from the text content field of the segmented semantic entity and counts the total number of valid characters, denoted as the number of words N in the entity's content. Then, the system calculates the original duration corresponding to the entity based on the base reading rate R (words / minute) in the timeline allocation rule. The calculation formula is: =N / R×60 (in seconds). Next, the system will use this original duration... With minimum segment duration The two values ​​are compared, and the larger value is taken as the final allocation duration for the entity. ,Right now =max( , After calculating the duration of a single entity, the system sequentially accumulates the durations according to the order of the semantic entities in the ordered set to determine their respective time axis intervals: the start time of the first entity is 0, and the end time is... Value; the start time of the second entity is equal to the end time of the first entity, and the end time is the start time plus its own. The value follows the same logic. Taking a scenario with 3 slides as an example, if slide 1 has 100 words, slide 2 has 300 words, and slide 3 has 50 words, with a basic reading speed of 200 words per minute and a minimum segment length of 5 seconds, then slide 1... =30 seconds, =30 seconds, the interval is [0s, 30s]; Page 2 =90 seconds, =90 seconds, interval [30s, 120s]; Page 3 =15 seconds, =15 seconds, with a range of [120s, 135s]. The system combines the start and end times of each segmented semantic entity into a time-series alignment parameter object. This object is then associated with the corresponding segmented semantic entity identifier and written into the configuration parameters of the sub-segment multimodal content. Ultimately, this constitutes part of the derived generation request and is sent to the underlying content generation engine.

[0089] In some embodiments, this step can be implemented in several ways: Optionally, a visual timeline editor can be provided, allowing users to manually drag sliders representing each segmented semantic entity to adjust its position and duration on the timeline. The system records these adjustments in real time as timing alignment parameters. Optionally, the system can invoke a speech duration prediction model. Inputting the text content of the segmented semantic entities, the model predicts the time required to read the text aloud using a specified timbre, using this as the allocated duration for more accurate automatic duration allocation. It is understood that different preset duration rules can also be applied based on the content type (e.g., title page, content page, end page), but this is not limited here.

[0090] In some embodiments, the automatically allocated duration may not meet the user's expectations. To address this, the intelligent interaction system provides a preview and fine-tuning interface after generating timing alignment parameters. In this interface, the user can see the duration allocated to each content segment and directly input values ​​for modification. Furthermore, the system offers overall acceleration or slowdown functions. Users can use a slider to proportionally scale the duration of all segments to quickly adjust the overall rhythm of the video, and then fine-tune individual segments.

[0091] It should be noted that in some embodiments, the intelligent interaction system will perform conflict avoidance before content synthesis. That is, the intelligent interaction system will extract background attribute features from the initial generated product and extract foreground attribute features from the configuration parameters; calculate the feature overlap between the background attribute features and the foreground attribute features; and update the foreground attribute features in the configuration parameters when the feature overlap is higher than a preset conflict threshold.

[0092] Background attributes refer to the visual characteristics of elements that form the basis of the content, such as the background color and main color scheme of a PowerPoint presentation. Foreground attributes refer to the visual characteristics of content that will be overlaid on top, such as the color of a digital human's clothing or the color of subtitles.

[0093] Specifically, when preparing a frame for a composite video, such as overlaying a digital human wearing blue clothing onto a PowerPoint presentation with blue as the primary color, the intelligent interactive system first extracts the background attribute features of the presentation (e.g., primary color #0000FF). Simultaneously, it extracts the foreground attribute features (e.g., clothing color #0000CC) from the digital human's configuration parameters. Then, the system calculates the distance between the two colors in the color space; the closer the distance, the higher the feature overlap. If the calculated overlap exceeds a preset conflict threshold, indicating potential visual indistinguishability, the system automatically updates the foreground attribute features, for example, by selecting a non-blue garment for the digital human from a pool of available clothing.

[0094] The background attribute feature extraction process includes: the system reads the page rendering image corresponding to the initial generated product from the context cache and performs dominant color analysis on the image. One implementation of dominant color analysis is to convert the image pixels from the RGB color space to the Lab color space (the Euclidean distance in this space has a better linear correspondence with the color difference perceived by the human eye), and then perform clustering calculations (e.g., K-Means clustering, with K set to 3) on the pixels belonging to the background region in the image. The centroid color value of the cluster with the most pixels in the clustering result is taken as the dominant color of the background of the page, denoted as vector B=( , , ).

[0095] The foreground attribute feature extraction process includes: the system reads the user-selected digital human image identifier from the current configuration parameters, and searches for the preset main color tone value of the clothing for that image in the digital human resource library based on the identifier. This value has been pre-calculated and stored as a vector in the Lab color space when it is entered into the library, denoted as F=( , , The feature overlap is calculated using the CIE76 color difference formula, which calculates the Euclidean distance ΔE between vectors B and F in the Lab color space. Since a smaller ΔE value indicates a closer similarity between two colors, the system defines feature overlap as the inverse mapping of ΔE, i.e., feature overlap = 1 / (1+ΔE). This value ranges from 0 to 1, with a smaller ΔE indicating a feature overlap closer to 1. The system compares this feature overlap with a preset conflict threshold (e.g., set to 0.033, corresponding to ΔE≈30). If the feature overlap is higher than this conflict threshold, a visual conflict is determined. The system then searches the digital human resource library for alternative clothing color schemes with a feature overlap lower than the conflict threshold that is lower than the current background color, and updates these alternative schemes to the foreground attribute feature field in the configuration parameters, thus completing conflict avoidance.

[0096] In some embodiments, the position of foreground elements (such as digital humans) may change within the frame, causing variations in their conflict relationships with different areas of the background. To address this, the intelligent interaction system incorporates the positional information of the foreground elements when calculating feature overlap. The system treats the foreground element as a mask, calculating only the background attribute features within the mask's coverage area, rather than the average features of the entire background. When the user drags the digital human to change its position on the interface, the system recalculates the feature overlap at the new position in real time and dynamically determines whether conflicts exist, achieving real-time conflict detection and avoidance based on position awareness.

[0097] S204. Send the derived generation request to the corresponding underlying content generation engine to obtain the global task number.

[0098] Refer to step S104, which will not be repeated here.

[0099] It's important to note that the global task number is not a local task identifier generated by a single underlying engine. Instead, it's a globally unique identifier uniformly assigned by the task orchestration layer of the intelligent interaction system when it receives a derived generation request. This identifier is generated using a distributed unique ID generation strategy, such as the UUID (Universally Unique Identifier) ​​algorithm or the snowflake algorithm, to ensure no numbering conflicts occur in high-concurrency scenarios. When a derived generation request involves the collaborative work of multiple underlying engines (e.g., generating a digital human video requires simultaneously calling the TS speech synthesis engine and the video rendering engine), the task orchestration layer associates the same global task number with all related subtasks. Specifically, the task orchestration layer internally maintains a mapping table. This table uses the global task number as the primary key, and its values ​​are a list of subtasks. Each item in the list records the engine type identifier of a subtask, the local task identifier returned by that engine, and the weight percentage of that subtask in the global task (used for subsequent calculation of the overall progress). When the frontend uses this global task ID to query the progress, the task orchestration layer iterates through all subtask entries corresponding to that ID in the mapping table, queries the local status of each underlying engine, and then performs a weighted calculation based on the weight ratio of each subtask to obtain a normalized global progress percentage, which is returned to the frontend. This mechanism allows the frontend to transparently track the overall execution status of complex generation tasks involving multiple heterogeneous engines by holding only a single global task ID.

[0100] S205. Extract the raw state data of the underlying content generation engine associated with the global task number and push it to the multi-agent linkage interface to calculate the task progress.

[0101] Refer to step S105, which will not be repeated here.

[0102] In some embodiments, the intelligent interaction system employs a dynamic polling strategy to monitor task progress. Specifically, the system extracts the engine type identifier of the underlying content generation engine and reads the estimated time consumption corresponding to the engine type identifier; determines the initial polling interval corresponding to the estimated time consumption and sends a status query request to the underlying content generation engine based on the initial polling interval; receives the raw status data returned by the underlying content generation engine and determines the current progress value in the raw status data; when the current progress value is less than a preset progress threshold, the initial polling interval is increased by a preset step size to obtain a corrected polling interval; the next status query request is sent based on the corrected polling interval, and the current progress value is pushed to the multi-agent interaction interface as the task progress.

[0103] Specifically, when a task begins, the intelligent interaction system first identifies its engine type and retrieves its estimated time from a configuration table, for example, 300 seconds. Based on the estimated time and a preset ratio, the system sets an initial polling interval, for example, 15 seconds. After the task starts, the system sends its first status query request to the underlying content generation engine at this initial polling interval. Upon receiving the returned raw status data, the system extracts the current progress value, for example, 10%. The system compares the current progress value with a preset progress threshold (e.g., 80%). If the current progress value is less than the threshold, the system determines that the task is still in the main processing stage. In this stage, progress changes slowly, and frequent queries will not yield significant new information. Therefore, the system increases the current polling interval by a preset step (e.g., 5 seconds) to obtain a corrected polling interval (e.g., 20 seconds), and sends the next status query request with this corrected interval. If the current progress value is greater than or equal to the threshold, the system determines that the task has entered the final stage. In this stage, the task is about to complete and requires more timely capture of the completion status. Therefore, the system shortens the current polling interval to a preset finalization polling interval (e.g., 5 seconds), and sends the next status query request with this finalization polling interval. Each time the current progress value is obtained, the system pushes it as task progress to the multi-agent interaction interface for display.

[0104] In some embodiments, this step can be implemented in several ways: Optionally, a strategy combining exponential backoff and linear increase can be adopted. The polling interval is very short at the start of the task; if the progress remains unchanged for several consecutive queries, the interval is increased exponentially; once a progress change is detected, the interval returns to a shorter one. Optionally, when returning a status, the backend can proactively provide a suggested next query time (next_poll_at), and the frontend initiates the next query entirely based on this suggested time, handing control over to the backend, which has a better understanding of the task execution. It is understandable that the polling interval can also be automatically extended when the user switches to other tabs, depending on whether the browser window is active, to save resources; this is not limited here.

[0105] In some embodiments, tasks may get stuck at a certain progress level for an extended period. To address this, the intelligent interaction system implements a progress stagnation timeout mechanism. If the number of consecutive queries or the total duration at the same progress percentage exceeds a preset threshold, the system determines that the task may be in a deadlock or abnormal. In this case, the system will proactively display a prompt to the user, indicating that task processing may encounter delays and requesting them to wait or contact support. It will also provide an option to manually abort the task, preventing the user from waiting indefinitely.

[0106] S206. When the task progress reaches the completion state, extract the derived generated products returned by the underlying content generation engine, and generate the target result file based on the initial generated products and the derived generated products.

[0107] Refer to step S106, which will not be repeated here.

[0108] S207. Receive the modification instruction sent by the multi-agent linkage interface and determine to update the semantic entity.

[0109] The modification command is a signal issued by the user when editing a portion of the content in the target result file after it has been generated, such as modifying the text of a slide in a video presentation. The updated semantic entity refers to the specific content that has been modified by the user, such as a new text string.

[0110] Specifically, after the target result file is generated and presented to the user in step S206, the user may make modifications in the preview interface (such as a video player with a timeline and the adjacent text box for the presentation slides). For example, if the user finds a typo in the slides at the 3-minute mark, they can correct it in the corresponding text box and click the "Save Changes" or "Regenerate" button. This click constitutes a modification instruction. After the intelligent interaction system detects this instruction, it will capture the modified content (i.e., update the semantic entity) and the location information of that content (such as page number, timestamp, or index in the data structure).

[0111] In some embodiments, the receipt of modification instructions and the determination of update entities can be implemented in several ways: Optionally, by listening to the onChange or onBlur events of the front-end input component, when the user modifies the content, the new content is updated in real time to the front-end state management tree, and the data item is marked as modified. When the user clicks the save button, the system traverses the state tree and finds all data items marked as modified as update semantic entities. Optionally, a form submission method is used, where each user modification is temporarily stored locally. When the "Apply All Modifications" button is clicked, the entire form data is compared with the original data, and the difference is the update semantic entity. It is understood that a version control-like approach can also be used, recording each user's editing operation as an operation log, and sending the log to the backend for processing upon submission; this is not limited here.

[0112] In some embodiments, a user may make multiple discontinuous modifications simultaneously. To address this, the intelligent interaction system batches these discrete modification commands. The system sets a short delay and starts a timer upon receiving the first modification command. If a new modification command is received before the timer expires, the timer is reset. Only after the timer expires normally does the system package all the updated semantic entities collected within this time window into a single set for subsequent processing. This avoids triggering a backend request for each rapid, consecutive modification by the user, thus merging operations and reducing the number of requests.

[0113] S208. Based on the updated semantic entity and the semantic entity in the context cache, determine the data segment to be modified.

[0114] The modified data segment refers to the specific data fragment that changes after comparing the old and new semantic entities. It includes not only the changed content but also its position information within the overall data structure.

[0115] Specifically, after receiving the updated semantic entity determined in step S207, the intelligent interaction system retrieves the corresponding old semantic entity from the context cache based on location information (such as index or ID). Then, the system compares the old and new entities. For example, if the update is a lecture transcript, the system compares the old and new text strings. This modified data segment object contains the updated text, its index within the entire lecture transcript array, and the old text content. This modified data segment is the core basis for subsequent local regeneration by the underlying engine.

[0116] In some embodiments, the determination of the modified data segment can be achieved in several ways: Optionally, for structured data (such as JSON objects), a deep comparison can be performed, recursively traversing the old and new objects to find all fields with different values, and recording the paths and new values ​​of these fields as the modified data segment. Optionally, for text data, a difference comparison algorithm (such as the Myers diff algorithm) can be used to determine the minimum set of modifications, not just replacing the entire string, but identifying the specific characters that have been added, deleted, or modified. This is more friendly to engines that need precise cost control. Understandably, it can also be determined based on business logic. For example, if the layout of a certain page in a PPT is modified, the modified data segment may be defined as a new layout configuration object containing all elements (text, images) of that page; this is not limited here.

[0117] In some embodiments, a modification may affect other data in a cascading manner. To address this, the intelligent interaction system considers the dependencies between data segments when determining which data segment to modify. The system maintains a dependency graph that records the relationships between different semantic entities. For example, the total duration of a video depends on the audio duration of each segment of the script. When a user modifies a segment of script text (updating a semantic entity), the system, when determining the modified data segment, not only marks the text as modified but also, along with other data, marks fields such as the audio duration and total video duration that depend on it as needing recalculation. This related information is then included in the modified data segment for comprehensive updates in subsequent steps.

[0118] S209. The modified data segment is sent to the corresponding underlying content generation engine to obtain the local derived generation product.

[0119] Among them, the locally derived output refers to the result returned by the underlying content generation engine after regenerating only the modified data segment. For example, it is just a newly generated audio segment of the modified speech text, rather than the complete audio track of the entire video.

[0120] Specifically, the intelligent interaction system sends the modified data segment determined in step S208 to the underlying content generation engine capable of handling this type of incremental task. For example, if the modified part is a speech, the system will send the new text and corresponding timbre parameters to the single-sentence generation interface of the TTS (Text-to-Speech) engine. After processing, the TTS engine will not return the audio of the entire project, but only the audio file corresponding to this small segment of text (i.e., the locally derived product). This process greatly reduces processing time and computing resources compared to sending the entire speech to the engine for synthesis again.

[0121] In some embodiments, the sending of modified data segments and the retrieval of partial artifacts can be achieved in several ways: Optionally, a specific API interface that supports incremental updates can be called, with the request body containing explicit instructions (such as "action": "update_segment") and the content of the modified data segment. After processing, the engine directly returns the file URL or Base64 data of the locally derived artifact in the response. Optionally, if the underlying engine does not support incremental updates, the frontend can simulate a mini-complete task request containing only the modified part. For example, to update an audio segment, the frontend can construct a TTS task request containing only this text segment, obtain the audio, and then perform subsequent splicing processing. It is understood that protocols supporting range requests can also be used to perform partial replacement on an existing large file, which is not limited here.

[0122] In some embodiments, the underlying content generation engine may require contextual information to ensure generation quality when processing incremental tasks. For example, when generating a dialogue, it needs to know the tone of the previous sentence. To address this, the intelligent interaction system attaches context window information when sending modified data segments. The system extracts a small amount of data (such as the text of the previous and next sentences) from the context buffer and sends it as additional parameters to the underlying engine. The engine can use this contextual information to ensure that the newly generated local products (such as speech) are consistent and coherent with the surrounding content in terms of emotion and style.

[0123] S210. Extract the current duration value of the locally derived product and extract the historical duration value corresponding to the modified data segment to calculate the time offset value.

[0124] The historical duration value refers to the duration of the old product corresponding to this data segment before the modification. The time offset value is the difference between the current duration and the historical duration, and this value can be positive, negative, or zero.

[0125] Specifically, after acquiring a locally derived product (such as a new audio clip), the intelligent interaction system obtains its precise duration through its metadata or by calling specialized analysis tools; this is the current duration value. Simultaneously, the system retrieves the duration of the old audio clip that was replaced from the context cache or information associated with the old product; this is the historical duration value. Then, the system subtracts the historical duration from the current duration to obtain the time offset value. For example, if the old audio clip is 5 seconds long and the newly generated one is 7 seconds long, the time offset value is +2 seconds. This value is crucial for subsequent adjustments to the entire timeline.

[0126] It should be noted that after the underlying content generation engine returns the partially derived product (such as a re-synthesized audio file), the intelligent interaction system obtains its precise duration by reading the duration field in the media container header information of that audio file, denoted as . (Unit: milliseconds). Simultaneously, the system reads the duration record of the historical generated artifact corresponding to the modified data segment before the modification from the context cache, denoted as... (The unit is also milliseconds). The time offset value ΔT is calculated as follows: ΔT = - When ΔT is positive, it means the new product is longer than the old product, and all subsequent content needs to be shifted backward by ΔT milliseconds on the timeline; when ΔT is negative, it means the new product is shorter than the old product, and all subsequent content needs to be contracted forward by |ΔT| milliseconds on the timeline; when ΔT is zero, it means the new and old products are of equal length, and the time position of subsequent content does not need to be adjusted. For example, suppose a user modifies the script of the third segment in a video, and the original audio duration... The modified and re-synthesized audio duration is 8500 milliseconds. If the time interval is 10200 milliseconds, then ΔT = 10200 - 8500 = +1700 milliseconds. This means that the start and end times of the 4th, 5th, and so on, up to the last segment, on the timeline must each be increased by 1700 milliseconds to ensure the temporal continuity of the entire video and the absence of overlap or gaps between segments. This ΔT value, along with the storage address of the locally derived product, is written to the context buffer, replacing the entry information corresponding to the original 3rd segment, for use in subsequent steps S212 to S216 when performing the actual replacement and translation operations.

[0127] In some embodiments, duration extraction and offset calculation can be implemented in multiple ways: Optionally, for audio and video files, the front end can obtain the file URL and then use HTML5... <audio>or <video>The element loads it, and when the event is triggered, the duration is read from the element's `duration` property. Historical durations can be stored in the context cache from the last generation. Optionally, the backend engine can directly analyze and calculate the duration while generating local artifacts, and write the new and old durations along with the offset into the response body and return it to the frontend, which can then directly parse and use it. It's understandable that for non-time-sequential content (such as replacing an image), the duration might be fixed at 0 or determined by the display logic; in this case, the time offset value is also 0, which is not limited here.

[0128] S211. Write the time offset value and the locally derived product into the context buffer.

[0129] Specifically, after calculating the precise time offset and obtaining the locally derived output (such as the URL of a new audio file), the intelligent interaction system updates this information in the context cache associated with the current session. This typically means replacing the old output information in the cache. For example, updating the audioUrl field of the corresponding index item in the lecture array to the new URL and updating its duration field to the new duration. Simultaneously, the calculated time offset is stored in a temporary variable or a dedicated pending offset queue for use in subsequent step S215.

[0130] In some embodiments, data writing can be implemented in several ways: Optionally, the corresponding data in the front-end state management library (such as Vuex Store) can be directly modified. A mutation is committed, replacing the old data with the new artifact information and duration, and triggering an action to handle the time offset. Optionally, the update operation can be encapsulated into a transaction, writing the new artifact information and time offset value as a whole to the cache. The transaction is only committed after all relevant data has been successfully updated. This ensures that if an exception occurs during the update process, it can be rolled back to the state before the modification, guaranteeing data consistency. It is understood that write operations can also be synchronized to the backend database to achieve multi-device synchronization and persistent storage; this is not limited here.

[0131] In some embodiments, multiple parallel local modification tasks may complete within a short period, generating multiple time offset values. To address this, the intelligent interaction system manages these time offset values ​​in an ordered manner when writing them to the context buffer. The system maintains an operation queue corresponding to the timeline. After each local update is completed, its time offset is not applied immediately. Instead, the offset value, along with its point of action on the timeline (timestamp), is pushed into the queue as an event object. Once all parallel modification tasks are completed, the system processes the events in the queue sequentially according to their timestamps, calculating the cumulative offset. This ensures that even with concurrent modifications, the final timeline adjustment is correct and ordered.

[0132] S212. Extract the target location index of the modified data segment in the target result file.

[0133] The target location index is a unique identifier used to precisely locate the position of the modified content (i.e., the modified data segment) within the overall structure of the target result file. For example, it can be an array index, a timestamp, or a hierarchical path.

[0134] Specifically, after a user completes modifications and issues a command, the intelligent interaction system needs to know which specific part of the final product the modification occurred in. For example, in a video consisting of 10 scenes, if a user modifies the script for the third scene, the intelligent interaction system will determine the target location index corresponding to the modified data segment as "Scene 3" or index number "2" (if counting starts from 0). This index is the basis for subsequent precise replacements and timing adjustments, ensuring the accuracy of incremental update operations.

[0135] In some embodiments, the extraction of the target position index can be achieved in several ways: Optionally, when rendering an editable interface on the front end, each editable data unit (such as each lecture script or each video clip) is bound to a globally unique identifier (UUID) assigned during initial generation. When a user modifies a unit, the system directly obtains the unit's UUID as its target position index. Optionally, for linearly structured files, such as subtitle files, the target position index can be the line number where the modified content is located. The system determines the line where the cursor is located by listening to the user's editing behavior, and then extracts the line number as the index. It is understood that other methods can also be used, such as using the start time of the content on the timeline as its unique index; this is not limited here.

[0136] In some embodiments, the target result file structure may be complex, and a simple index may not be able to uniquely determine its location, such as nested, combined content. To address this, the intelligent interaction system employs a path index. This index, similar to a file system path (e.g., scenes / 2 / layers / 3 / text), accurately describes the precise location of the modified data segment within a multi-level nested structure. When a user interacts with an element in the visual editor, the system dynamically constructs its corresponding path index based on the element's hierarchical relationship in the DOM tree or scene graph.

[0137] S213. Replace the historical generated product corresponding to the historical duration value with the locally derived generated product.

[0138] Among them, historical generated artifacts refer to old content fragments located at the target location index before modification, such as old audio or video fragments.

[0139] Specifically, the intelligent interaction system uses the target location index obtained in step S212 to find the corresponding entry in the data model of the target result file maintained internally. This entry contains information about historically generated products, such as their storage address (URL) and duration (historical duration value). The system then updates the information of this entry with the information of the locally derived generated products, that is, replaces the old URL and old duration with the new URL and the new duration (current duration value). This operation completes the content update at the data level.

[0140] In some embodiments, the replacement operation can be implemented in several ways: Optionally, in an array of objects representing the video timeline, the attribute of the object at the target position index can be directly modified. For example, timeline[index] = {assetUrl: newUrl, duration: newDuration, ...}. This method is suitable for direct manipulation of data structures in memory. Optionally, if the structure of the target result file is stored in a database, the system will execute a database update instruction, such as UPDATE timeline_segments SET asset_url = 'newUrl', duration = newDuration WHERE id = 'segment_uuid', precisely locating and updating the record using a unique identifier. It is understood that an immutable data update method can also be used, that is, instead of directly modifying the original data structure, a new copy of the replaced data structure is created to facilitate state traceability and undoing operations; this is not limited here.

[0141] In some embodiments, after a replacement operation, differences in format or encoding between the old and new products may lead to compatibility issues in subsequent playback or compositing. To address this, the intelligent interactive system adds a compatibility check before performing the replacement. The system checks the metadata (such as encoding format, resolution, and frame rate) of the locally derived product and compares it with the standard format of other products in the target result file. If an inconsistency is found, the system first sends the locally derived product to a fast transcoding service to convert it to the standard format before performing the replacement operation, ensuring the overall consistency and playback stability of the final composite file.

[0142] S214. Based on the target location index, extract the subsequent generated products located after the locally derived generated products in the target result file.

[0143] The subsequent generated artifacts refer to all content fragments that follow the replaced artifacts in the temporal or logical order of the target result file.

[0144] Specifically, after the replacement is completed in step S213, the intelligent interactive system needs to shift all subsequent content on the timeline. To achieve this, the system first needs to identify this "subsequent content." Using the target location index, the system locates all entries in its maintained target result file data model whose index value is greater than the target location index, or all entries whose start timestamp is greater than the end timestamp of the replaced content. This set of filtered entries is the subsequent generated product.

[0145] In some embodiments, the extraction of subsequent generated products can be achieved in several ways: Optionally, if the data model is an array, the system can use array slicing operations, such as `subsequentProducts = timeline.slice(index + 1)`, to obtain all elements after the target position index at once, forming a new array. Optionally, if the data model is a linked list structure, the system will start from the node at the target position index and traverse the linked list backwards, collecting all subsequent nodes until the end of the linked list. It is understood that for a multi-track timeline, the system needs to traverse all tracks and collect all products on each track whose timestamps are after the modification point; this is not limited here.

[0146] In some embodiments, there may be instances where subsequently generated artifacts contain absolutely positioned elements unrelated to the timeline (e.g., a watermark that always floats in the upper right corner). To address this, the intelligent interaction system filters artifacts based on their attributes when extracting them. The system checks the "timeline binding" or "positioning mode" attribute of each artifact. Artifacts marked as "relatively positioned" or "following the timeline" are extracted for subsequent timing adjustments; while artifacts marked as "absolutely positioned" are excluded from this extraction, ensuring their position is unaffected by time offsets and guaranteeing the stability of these elements.

[0147] S215. Extract the timestamp parameters of the subsequently generated products, and add the time offset value to the timestamp parameters to obtain the translation timestamp parameters.

[0148] Specifically, the intelligent interaction system iterates through all subsequent generated artifacts extracted in step S214. For each artifact, the system reads its original timestamp parameters, such as {startTime: 120, endTime: 135}. Then, the system adds the time offset value calculated in step S210 (e.g., +5 seconds) to these timestamps respectively. The result is a new translation timestamp parameter, such as {startTime: 125, endTime: 140}. The system performs this operation on all subsequent generated artifacts, thereby completing the backward translation of the entire timeline at the data level.

[0149] In some embodiments, timestamp overlay and shifting can be implemented in several ways: Optionally, a loop structure can be used to perform addition on the startTime and endTime properties of each object in the subsequent generated product array and update them directly. Optionally, a functional programming map operation can be used to traverse the subsequent generated product array, returning a new object with the updated shifted timestamp parameter for each product, ultimately generating a completely new array of subsequent products with updated timestamps. This method helps maintain data immutability. It is understood that the overlay operation can also handle negative time offset values, that is, when the new product is shorter than the old product, the timestamps of all subsequent products will be advanced accordingly; this is not limited here.

[0150] In some embodiments, complex non-linear dependencies exist between subsequent products, where simple linear translation can lead to logical errors. For example, the timing of a subtitle's appearance might depend on the end of another video segment, not just its predecessor. To address this, the intelligent interaction system updates timestamps based on a dependency graph. Instead of linearly stacking offsets, the system propagates updates across the graph, starting from the modified node. Each node's timestamp is recalculated based on the new timestamps of all its preceding dependent nodes, rather than simply adding a fixed offset. This approach correctly handles complex temporal dependencies.

[0151] S216. Update the arrangement position of the subsequently generated products in the target result file based on the translation timestamp parameter to obtain the updated result file.

[0152] Specifically, after updating the timestamp parameters of all subsequent artifacts in step S215, the intelligent interactive system possesses a complete and correct new content layout blueprint. This blueprint includes the replaced locally derived artifacts and all subsequently generated artifacts whose positions have been shifted. Based on this new blueprint, the system calls the final compositing or packaging engine. The engine will then stitch together the various content fragments (unmodified, newly generated, and shifted) in the correct order according to the new timestamp parameters, ultimately outputting a single, seamless updated result file, such as a new MP4 video file.

[0153] In some embodiments, the generation of the updated result file can be achieved in several ways: Optionally, the updated complete data model (e.g., a JSON file describing the timeline) is sent to a backend compositing service, which then calls professional tools such as FFmpeg to perform a series of operations such as editing, splicing, and mixing based on the JSON description, generating the final video file and returning its download address. Optionally, for web preview, the system can dynamically adjust the HTML5 based on the updated timestamp parameters on the front end. <video>or <audio>The playback sequence and timing of elements enable an instant preview without requiring backend re-compositing, allowing users to immediately see the changes. Understandably, for non-video files, such as updating an article with mixed text and images, the system will regenerate the HTML code based on the new layout data; this is not a limitation here.

[0154] In some embodiments, frequent modifications can necessitate re-combining the entire file each time, resulting in lengthy processing times even if most content remains unchanged. To address this, the intelligent interaction system employs a segmented rendering and caching mechanism. The system logically divides the entire target result file into multiple independent chunks. When a portion is modified, the system only re-renders the affected chunk and adjacent chunks that need to be re-assembled due to temporal changes. Unaffected, previously rendered chunks are directly read from the cache. Finally, these rendered chunks and the chunks read from the cache are quickly concatenated, significantly reducing the time required to generate the updated result file.

[0155] In this embodiment, by adopting a technical solution in the multi-agent linkage generation process, semantic entities extracted from the initial generation product are shared through the context cache, and subsequent derivative content generation is driven based on the shared data. Therefore, efficient data reuse and seamless connection are achieved between each generation node, which effectively solves the problems of broken cross-modal content generation process, repeated information processing, and serious waste of model resources in the prior art. Thus, it realizes the coherent, efficient, and economical automated orchestration and generation of AIGC multimodal content.

[0156] The intelligent interaction system in this application embodiment is described below from the perspective of hardware processing. Please refer to [link / reference]. Figure 3 This is a schematic diagram of the physical device structure of an intelligent interactive system in an embodiment of this application.

[0157] It should be noted that, Figure 3 The structure of the intelligent interaction system shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0158] like Figure 3 As shown, the intelligent interactive system includes a CPU 301, which can perform various appropriate actions and processes according to a program stored in ROM 302 or a program loaded from storage section 308 into RAM 303, such as executing the methods described in the above embodiments. RAM 303 also stores various programs and data required for system operation. The CPU 301, ROM 302, and RAM 303 are interconnected via bus 304. I / O interface 305 is also connected to bus 304.

[0159] The following components are connected to I / O interface 305: input section 306 including audio input devices, push-button switches, etc.; output section 307 including a liquid crystal display (LCD) and audio output devices, indicator lights, etc.; storage section 308 including a hard disk, etc.; and communication section 309 including a network interface card such as a LAN (Local Area Network) card, modem, etc. Communication section 309 performs communication processing via a network such as the Internet. Drive 310 is also connected to I / O interface 305 as needed. Removable media 311, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., are installed on drive 310 as needed so that computer programs read from them can be installed into storage section 308 as needed.

[0160] Specifically, according to embodiments of this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program including a computer program for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 309, and / or installed from removable medium 311. When the computer program is executed by CPU 301, it performs the various functions defined in this application.

[0161] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. Each block in a flowchart or block diagram may represent a module, segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those shown in the drawings.

[0162] Specifically, the intelligent interaction system in this embodiment includes a processor and a memory. The memory stores a computer program. When the computer program is executed by the processor, it implements the AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement provided in the above embodiment.

[0163] In another aspect, this application also provides a computer-readable storage medium, which may be included in the intelligent interactive system described in the above embodiments; or it may exist independently and not assembled into the intelligent interactive system. The storage medium carries one or more computer programs, which, when executed by a processor of the intelligent interactive system, enable the intelligent interactive system to implement the AIGC multimodal content generation and task linkage method based on multi-agent menu arrangement provided in the above embodiments.

[0164] The above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit it. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this application.

[0165] As used in the above embodiments, depending on the context, the term "when..." can be interpreted as meaning if... or after... or in response to determining... or in response to detecting... Similarly, depending on the context, the phrase "when determining... or if (the stated condition or event) is interpreted as meaning if determining... or in response to determining... or in response to detecting (the stated condition or event)" or in response to detecting (the stated condition or event).< / audio> < / video> < / video> < / audio>

Claims

1. A method for AIGC multimodal content generation and task linkage based on multi-agent menu arrangement, characterized in that, The method, applied to intelligent interactive systems, includes: In the multi-agent linkage interface, obtain the initial generation request of the first segment of multimodal content, and send the initial generation request to the underlying content generation engine; Extract the semantic entities of the initial generated products returned by the underlying content generation engine, write the semantic entities into the context cache, and generate cross-modal shared data; Receive the flow instructions from the secondary generation node in the multi-agent linkage interface, read the semantic entities in the cross-modal shared data to fill the configuration parameters of the secondary multimodal content, and generate the derivative generation request of the secondary multimodal content. The derived generation request is sent to the corresponding underlying content generation engine to obtain a global task number; Extract the raw state data of the underlying content generation engine associated with the global task number and push it to the multi-agent linkage interface to calculate the task progress. When the task progress reaches the completion state, the derived generated products returned by the underlying content generation engine are extracted, and the target result file is generated based on the initial generated products and the derived generated products.

2. The method according to claim 1, characterized in that, The step of extracting the semantic entities of the initial generated product returned by the underlying content generation engine, writing the semantic entities into the context cache, and generating cross-modal shared data specifically includes: Extract the structural boundary identifier of the initial generated product returned by the underlying content generation engine; The initial generated product is segmented according to the structural boundary identifier to obtain segmented semantic entities; The segmented semantic entities and the structural boundary identifiers are written into the context cache to generate the cross-modal shared data.

3. The method according to claim 2, characterized in that, After the step of writing the segmented semantic entity and the structural boundary identifier into the context buffer to generate the cross-modal shared data, the method further includes: Read the segmented semantic entities and the structural boundary identifiers from the cross-modal shared data; Extract the preset time axis allocation rules from the secondary generation nodes; Based on the structural boundary identifier and the time axis allocation rule, the segmented semantic entities are mapped to the corresponding time axis intervals to obtain the time alignment parameters; The timing alignment parameters are written into the configuration parameters of the sub-segment multimodal content to generate the derived generation request.

4. The method according to claim 1, characterized in that, Before the step of reading semantic entities from the cross-modal shared data to populate the configuration parameters of the secondary multimodal content and generating a derived generation request for the secondary multimodal content, the method further includes: Extract the background attribute features from the initial generated product and extract the foreground attribute features from the configuration parameters; Calculate the feature overlap between the background attribute features and the foreground attribute features; When the feature overlap is higher than a preset conflict threshold, the foreground attribute feature in the configuration parameters is updated.

5. The method according to claim 1, characterized in that, After the step of extracting the derived generated products returned by the underlying content generation engine when the task progress reaches the completion state, and generating the target result file based on the initial generated products and the derived generated products, the method further includes: Receive the modification instruction sent by the multi-agent linkage interface and determine to update the semantic entity; Based on the updated semantic entity and the semantic entity in the context cache, determine the data segment to be modified; The modified data segment is sent to the corresponding underlying content generation engine to obtain a local derived generation product; Extract the current duration value of the locally derived product and extract the historical duration value corresponding to the modified data segment to calculate the time offset value; The time offset value and the locally derived product are written into the context cache.

6. The method according to claim 5, characterized in that, After the step of writing the time offset value and the locally derived product into the context buffer, the method further includes: Extract the target location index of the modified data segment in the target result file; Replace the historical generated product corresponding to the historical duration value with the locally derived generated product; Based on the target location index, extract the subsequent generated products located after the locally derived generated products in the target result file; Extract the timestamp parameters of the subsequently generated products, and superimpose the time offset value onto the timestamp parameters to obtain the translation timestamp parameters; The arrangement position of the subsequently generated products in the target result file is updated based on the translation timestamp parameter to obtain the updated result file.

7. The method according to claim 1, characterized in that, The step of extracting the raw state data of the underlying content generation engine associated with the global task number and pushing it to the multi-agent linkage interface to calculate the task progress specifically includes: Extract the engine type identifier of the underlying content generation engine, and read the estimated time value corresponding to the engine type identifier; Determine the initial polling interval length corresponding to the estimated time value, and send a status query request to the underlying content generation engine according to the initial polling interval length; Receive the raw status data returned by the underlying content generation engine, and determine the current progress value in the raw status data; When the current progress value is less than the preset progress threshold, the initial polling interval is increased by a preset step size to obtain the corrected polling interval. The next status query request is sent according to the modified polling interval, and the current progress value is pushed to the multi-agent linkage interface as the task progress.

8. An intelligent interactive system, characterized in that, The intelligent interactive system includes: one or more processors and a memory; the memory is coupled to the one or more processors, the memory is used to store computer program code, the computer program code including computer instructions, and the one or more processors call the computer instructions to cause the intelligent interactive system to perform the method as described in any one of claims 1-7.

9. A computer-readable storage medium comprising instructions, characterized in that, When the instructions are executed on the intelligent interactive system, the intelligent interactive system performs the method as described in any one of claims 1-7.

10. A computer program product, characterized in that, When the computer program product is run on the intelligent interactive system, the intelligent interactive system performs the method as described in any one of claims 1-7.

Images