Group chat control methods, electronic devices, storage media and software products

By introducing a response status mechanism in group chat sessions and using session identifiers to store response status, distinguishing between silent and active states, the problems of frequent model calls and unstable response status in existing technologies are solved, achieving efficient and stable group chat control.

CN123123307APending Publication Date: 2026-11-17MOBVOI INNOVATION TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611544435.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-09-30
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In group chat sessions, existing technologies require frequent calls to the model to determine whether to generate a reply, which increases processing latency and computational overhead. Furthermore, the response status cannot be stably maintained, and the default processing cannot be kept consistent after the model is changed.

Method used

By introducing a response status mechanism in group chat sessions, the response status is stored using session identifiers to distinguish between silent and active states. Silent states do not generate responses, while active states call the model to generate responses. The response status is retained after the instance is destroyed, thus avoiding duplicate judgments.

Benefits of technology

It reduces the number of model calls, maintains the stability and consistency of response status, avoids the computational overhead of irrelevant messages, adapts to model changes without special training, and achieves efficient group chat control.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123123307A_ABST
    Figure CN123123307A_ABST
Patent Text Reader

Abstract

This disclosure provides a group chat control method, an electronic device, a readable storage medium, and a computer program product. The group chat control method includes: in response to receiving a message in a group chat session, writing the message into a session context; in response to the message's accompanying data carrying an activation signal, determining the response state of a first agent as active; in response to the accompanying data not carrying an activation signal, reading the stored response state using the session identifier of the group chat session, determining a silent state or an active state as the first agent's response state when reading is successful, an illegal value is read, or no state is read, determining the first agent's response state as silent; in response to a silent response state, skipping model calls, not generating a reply, storing the silent state, and sending an end signal carrying the silent state; in response to an active response state, calling the model to generate a reply, determining the first agent's next response state based on the reply, storing the next response state, returning a reply to the group chat session, and sending an end signal carrying the next response state.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This disclosure relates to a group chat control method, electronic device, storage medium, and program product. Background Technology

[0002] With the widespread application of large language models in dialogue scenarios, intelligent agents have begun to participate as participants in multi-person online group chats. A group chat typically involves multiple human members and one or more intelligent agents. Human members converse directly with each other, mention an intelligent agent during conversations, or have one agent forward a message to another. Unlike a question-and-answer session with only one user, many messages in a group chat are inherently conversations between human members. The intelligent agent needs to receive these messages and decide whether to generate a response. This control over "whether to generate a response" is called group chat control.

[0003] One existing approach is to call the model based on a fixed number of messages, and the model determines whether to intervene in the group chat, what the intervention should include, and to whom. As the number of messages in the group chat continues to increase, this approach repeatedly checks the message count.

[0004] Another existing approach is to perform a relevance assessment on each incoming message, and only call the model to generate a response if the message is deemed relevant. The assessment itself still requires a calculation on the message.

[0005] Another approach is to train a separate model to determine whether it should speak in the current round. This ability is dependent on the model being trained, and cannot be directly applied if the model is changed. A common practice is to have the model generate a response as soon as a message is received, and then let the backend decide whether to display the response. In this case, the model call has already occurred.

[0006] The main problem with the above approach is that the act of deciding whether to generate a reply itself requires a model call or an evaluation calculation. In group chat sessions, messages unrelated to any particular agent often make up the majority, and the number of decisions still increases with the number of messages, leading to higher processing latency and computational overhead.

[0007] Furthermore, if the result of whether to generate a reply in the next round, already determined in the previous round, is only stored during the current run of processing that message, it will become unusable when the next message is processed in a different run. If the model does not explicitly specify whether to generate a reply in the next round in a particular reply, subsequent messages lack a stable default handling mechanism, and the specially trained speech judgments cannot be retained when the model is changed. Summary of the Invention

[0008] This disclosure provides a group chat control method, electronic device, storage medium, and program product.

[0009] According to one aspect of this disclosure, a group chat control method is provided, applied to a first intelligent agent, comprising: In response to receiving a message in a group chat session, the message is written into the session context; In response to the activation signal carried by the accompanying data of the message, the response state of the first agent is determined to be active. In response to the fact that the accompanying data does not carry the activation signal, the stored response state is read using the session identifier of the group chat session. When a silent state or an active state is read, it is determined as the response state of the first agent. When reading fails, an illegal value is read, or no value is read, the response state of the first agent is determined as a silent state. In response to the silence state, skip the model call, do not generate a reply, store the silence state, and send an end signal carrying the silence state. In response to the active state of the response, the model is invoked to generate a reply, the next response state of the first agent is determined based on the reply, the next response state is stored, the reply is returned to the group chat session, and an end signal carrying the next response state is sent.

[0010] Optionally, the activation signal is a signal used to instruct the first agent to generate a response, including a first activation signal or a second activation signal.

[0011] Optionally, the first activation signal is the activation signal carried in the accompanying data when the user mentions the first agent in the group chat session, and the second activation signal is the activation signal carried in the accompanying data when the second agent forwards a message to the first agent.

[0012] Optionally, the method further includes: a first agent separating text content and accompanying data from the message, and detecting whether the accompanying data carries the first activation signal or the second activation signal.

[0013] Optionally, the reply carries a status declaration, which is used to indicate the next response status. Determining the next response status of the first agent based on the reply includes: parsing the status declaration from the reply to obtain the next response status.

[0014] Optionally, storing the next response state includes replacing the stored response state of the first agent with the next response state using the session identifier as the key.

[0015] Optionally, the method further includes: in response to a mention in the message that points to a target agent rather than a first agent, the first agent forwards a request and necessary context to the target agent, and writes an activation signal in the accompanying data of the forwarded message, so that the target agent can determine the target agent's response state as an active state.

[0016] Optionally, the step of invoking the model to generate a response includes: constructing the input of the model using the session context, the message, and the callback tool declaration; invoking the model to generate a response based on the input; and the callback tool declaration being used to declare callable tools to the model.

[0017] Optionally, the callback tool declaration includes a declaration of a round declaration tool, which is a tool that is not executed.

[0018] Optionally, when the model generates a response, it calls the round declaration tool, and the parameters called are used to indicate the next response state of the first agent.

[0019] Optionally, if the response does not carry a status declaration, the next response status is determined to be silent.

[0020] Optionally, the first agent that processes the message is an instance instantiated in response to receiving the message. The instance is destroyed after returning the reply to the group chat session. The stored response state of the first agent is retained after the instance is destroyed, so that instances that process subsequent messages in the group chat session can read it.

[0021] Optionally, the termination signal is used to allow the front end to switch the display state of the first intelligent agent.

[0022] Optionally, the method further includes: asynchronously triggering compression of the session context after the end signal is sent.

[0023] According to another aspect of this disclosure, an electronic device is provided, including a memory and a processor, the memory storing a computer program, the processor executing the computer program to implement the steps of a group chat control method according to any embodiment of this disclosure.

[0024] According to another aspect of this disclosure, a readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of a group chat control method according to any embodiment of this disclosure.

[0025] According to another aspect of this disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements a group chat control method according to any embodiment of this disclosure.

[0026] The group chat control method disclosed herein has at least one of the following beneficial effects: messages unrelated to the first agent in the group chat session no longer trigger model calls, reducing the number of model calls; the response state is stored with the session identifier as the key and is retained after the instance is destroyed, allowing instances that process subsequent messages to read it, ensuring reliable continuation of the response state under a stateless architecture; when the reply does not carry a state declaration, the next response state is determined to be a silent state, and the model safely reverts to silence when it omits a declaration, preventing the generation of incorrect replies; the next response state is determined based on the reply generated by the model, eliminating the need for specialized training of the model, and the model can still be determined whether to generate a reply after replacement or upgrade. Attached Figure Description

[0027] The accompanying drawings illustrate exemplary embodiments of the present disclosure and, together with the description thereof, serve to explain the principles of the present disclosure. These drawings are included to provide a further understanding of the present disclosure and are incorporated in and constitute a part of this specification.

[0028] Figure 1 This is a schematic diagram illustrating an application scenario of a group chat control method according to one embodiment of this disclosure.

[0029] Figure 2 This is a flowchart illustrating a group chat control method according to one embodiment of the present disclosure.

[0030] Figure 3 This is a schematic diagram of a process for separating text content and accompanying data and detecting activation signals according to one embodiment of the present disclosure.

[0031] Figure 4 This is a flowchart illustrating the parsing status declaration of one embodiment of this disclosure.

[0032] Figure 5 This is a schematic diagram of the process of storing the next response state according to one embodiment of the present disclosure.

[0033] Figure 6 This is a schematic diagram of signaling forwarded to a target intelligent agent according to one embodiment of this disclosure.

[0034] Figure 7 This is a schematic diagram of the process of generating a response using a call model according to one embodiment of this disclosure.

[0035] Figure 8 This is a schematic diagram of a round declaration tool according to one embodiment of this disclosure.

[0036] Figure 9 This is a schematic diagram of the system architecture of a group chat control method according to one embodiment of the present disclosure.

[0037] Figure 10 This is a timing diagram illustrating the multi-round connection between the silent state and the active state in one embodiment of this disclosure.

[0038] Figure 11 This is a schematic diagram of the transition of the first agent's response state (silent state / active state) in one embodiment of this disclosure.

[0039] Figure 12 This is a schematic block diagram of an electronic device according to one embodiment of the present disclosure. Detailed Implementation

[0040] The present disclosure will now be described in further detail with reference to the accompanying drawings and examples. It should be understood that the specific examples described herein are for illustrative purposes only and are not intended to limit the scope of the disclosure. Furthermore, it should be noted that, for ease of description, only the parts relevant to the present disclosure are shown in the accompanying drawings.

[0041] It should be noted that, where there is no conflict, the embodiments and features described in this disclosure can be combined with each other. The technical solutions of this disclosure will now be described in detail with reference to the accompanying drawings and embodiments.

[0042] Figure 1 This is a schematic diagram illustrating an application scenario of a group chat control method according to one embodiment of this disclosure.

[0043] refer to Figure 1 The group chat control method of this embodiment is applied to a first intelligent agent and runs on a computer or server. In this embodiment, the first intelligent agent is a coordinating AI participant (DiscussionCoordinator, also known as a collaborator) in the group chat session, responsible for observing and remembering, summarizing responses, and forwarding tasks to the target intelligent agent when necessary. For a single group chat session, the first intelligent agent operated by this method is logically singular: the group chat session maintains a response state with the session identifier as the key, corresponding to this one first intelligent agent. A group chat session can also contain multiple human members, as well as other intelligent agents such as a second intelligent agent (an upstream forwarder relative to the first intelligent agent) and a target intelligent agent (a downstream forwarded agent relative to the first intelligent agent); these other intelligent agents are not the first intelligent agent referred to in this method, and are distinguished by role, as detailed below. If multiple coordinating AI participants are deployed in the same group chat, each coordinating AI participant acts as its own first intelligent agent, and each isolates its response state according to its own session identifier (or its own corresponding storage key), without affecting each other.

[0044] A group chat session can have multiple human members and a logical first agent (as mentioned above, if multiple coordinating AI participants are deployed, each acts as its own first agent). Human members send messages to each other, and the first agent acting under this method receives these messages. A message includes text for reading, as well as accompanying data carried separately from the text. The accompanying data carries control information, such as front-end activation signals injected by the group chat front-end interface, activation signals passed through during cross-agent delegation (i.e., delegation pass-through signals), etc., and is not mixed with the text for reading.

[0045] A large number of messages in a group chat session are conversational messages between human members. The first agent should not generate replies to these messages, but it must record these messages in the conversation context of the group chat session so that when a reply is needed later, the reply can be based on the continuously written conversation context.

[0046] The server receives group chat messages based on a stateless architecture (e.g., via a server-pushed stream SSE interface). It's important to note that the first agent logically remains the same (or each isolated) coordinating AI participant mentioned above. During runtime, for each message received by the message access layer, a new first agent object (one running instance) is instantiated to process that message; this object is destroyed after processing. The processing of two consecutive messages can fall on different instances, thus the same runtime process does not need to span two messages. Each instance shares the response state stored externally according to the session identifier, rather than each storing a separate, independent copy of the first agent in memory.

[0047] Figure 2 This is a flowchart illustrating a group chat control method according to one embodiment of the present disclosure.

[0048] refer to Figure 2 The group chat control method M100 of this embodiment is applied to a first intelligent agent and includes: S102. In response to receiving a message in a group chat session, write the message into the session context; S104. In response to the activation signal carried by the accompanying data of the message, the response state of the first agent is determined to be active. S106. In response to the fact that the accompanying data does not carry the activation signal, the stored response state is read using the session identifier of the group chat session. When a silent state or an active state is read, it is determined as the response state of the first agent. When reading fails, an illegal value is read, or no value is read, the response state of the first agent is determined as a silent state. S108. In response to the response state being silent, skip the model call, do not generate a reply, store the silent state, and send an end signal carrying the silent state. S110. In response to the response state being active, the model is invoked to generate a reply, the next response state of the first agent is determined based on the reply, the next response state is stored, the reply is returned to the group chat session, and an end signal carrying the next response state is sent.

[0049] In this embodiment, the session context is the message record already written in the group chat session. The attached data is data received along with the message, carried separately from the text content, and used to carry control information; for example, the attached data may carry a front-end activation signal injected by the group chat front-end operation interface when the user mentions the first agent, or it may carry an activation signal (i.e., a delegation pass-through signal) that is passed through during cross-agent delegation.

[0050] An activation signal is a control message in the accompanying data used to instruct the first agent to generate a response. For example, when a user mentions the first agent in a group chat using @mention, the group chat front-end interface can write a front-end activation signal with an activation value into the accompanying data of the message. The activation signal in the accompanying data only counts as a carried activation signal in step S104 if it has an activation value; if it has a silent value, it is treated the same as if there is no activation signal in the accompanying data, and proceeds to step S106.

[0051] The response state (i.e., the coordination state) indicates whether the first agent is in a silent or active state in relation to the group chat session.

[0052] The silent state is a state in which the model is not invoked and no response is generated.

[0053] The active state is the state in which the model is invoked and a response is generated.

[0054] The session identifier is used to distinguish different group chat sessions. Both reading and storing use the session identifier of the group chat session to which this message belongs.

[0055] In this implementation, only the coordinator session reads and writes the aforementioned response state storage (i.e., coordination state storage) with the session identifier as the key. The naming convention of the session identifier distinguishes the coordinator session from the coordinated team agent session, thereby avoiding misreading and writing the team agent session's state as the first agent's response state. Different group chat sessions are isolated from each other by the response state key corresponding to their respective session identifiers, ensuring that multiple first agents or multiple groups do not affect each other during concurrency. When reading the response state storage fails, it is defaulted to a silent state; when writing fails, only an alarm is recorded, without blocking the return of already generated replies or the issuance of an end signal.

[0056] The next response status is the response status that is available for subsequent messages to read after this processing is completed. The end signal is the signal issued when this processing ends. The model is a model that generates responses based on the session context and the current message, and can be various large language models, multimodal models, etc., which are not specifically limited in this disclosure.

[0057] In step S102, each time the first agent receives a message from the group chat session, it first writes the message into the session context (i.e., context accumulation) before making subsequent judgments. When writing into the session context, it doesn't matter whether the response state is silent or active. This way, even if no reply is generated for this message, it will still exist in the session context. Once a reply is generated later, the session context on which the reply is based is continuous, rather than starting recording from the active message.

[0058] In step S104, when the accompanying data of this message carries an activation signal with an activation value, the first agent determines the response state as active. The previously stored silent state is overwritten by this message, and the first agent prepares to generate a reply.

[0059] In step S106, when the accompanying data does not carry an activation signal with an activation value, the first agent does not force itself to enter the activation state without this message, but instead reads the already stored response state using the session identifier of the group chat session.

[0060] If the read value is either silent or active, that value is determined as the response status for this round. If the read fails, the read value is neither silent nor active, or there is no record under the above session identifier, the response status is determined to be silent.

[0061] No response is generated by default when there is no activation signal, to avoid treating ordinary messages between human members as messages that require a response.

[0062] Steps S104 and S106 are executed selectively based on whether the attached data of this message carries an activation signal (i.e., the coordination state parsing module determines the response state of this round according to a three-level priority: the front-end activation signal takes precedence over the delegation pass-through signal, the delegation pass-through signal takes precedence over persistent storage, and the default is silent). For the same message, the response state will not be determined as active at the same time, and then determined again based on the reading result.

[0063] In step S108, when the response state is silent (i.e., the silence determination is met), the first agent skips the model call (i.e., zero-model inference), does not generate a reply, stores the silent state according to the session identifier of the group chat session, and sends an end signal carrying the silent state. This message has already been written into the session context in step S102, and silence does not result in the loss of the context.

[0064] This step avoids calling the model to determine whether to reply to every message, preventing the number of model calls from increasing with the number of group chat messages. In a silent state, this call is not performed, and irrelevant messages will no longer trigger model inference.

[0065] In step S110, when the response state is active, the first agent calls the model to generate a reply and identifies whether forwarding is needed (i.e., entering the planning module, including model and route identification). The model generates a reply based on the already written session context. The first agent then determines the next response state based on the above reply, stores the next response state (i.e., writes it back to the coordination state), returns the above reply to the group chat session, and sends an end signal carrying the next response state.

[0066] If the previous execution was step S110, the next response status read in step S106 is the one stored in the above steps. If the previous execution was step S108, the silent state stored according to the above session identifier is the one read in step S106. Steps S108 and S110 are executed selectively based on the response status.

[0067] This implementation uses a silent state and an active state to distinguish whether a response is generated. When there is no activation signal, the response is processed according to the stored response state; if no valid value is found, the agent enters a silent state and skips the model call. When an activation signal is present, the agent enters an active state, generates a response, and then stores the next response state back into the aforementioned session identifier. The first agent can thus continuously accumulate session context while only generating model calls and responses in the active state.

[0068] In other words, the first agent first records each group chat message. If the message contains an activation signal that prompts a reply, the first agent enters an active state, invokes the model, provides a reply, and then saves whether to remain silent or continue active next time. If there is no activation signal, the first agent checks the previously saved state of this session.

[0069] If a silent state is found, or a response state is not found, or the found state is neither silent nor active, the first agent does not call the model or reply in this instance, and stores the silent state as part of the conversation. For example, in a casual conversation, the first agent does not need to call the model again to determine whether to reply.

[0070] In summary, in terms of quantity: Logically, there is only one first agent in a single group chat session; each message instantiates a new first agent object during runtime, and the logical first agent continues to function under the external response state of the aforementioned session identifier after the object is destroyed; the second agent (upstream forwarder) and the target agent (downstream forwarded party) are other agents and are not counted in the number of first agents; the same entity may play two roles in different rounds, but the terminology is differentiated according to role. The first agent is the coordinating AI participant (Discussion Coordinator, also known as a collaborator) in the group chat session; the accompanying data is the control information carrier carried separately from the text in the message; the activation signal is the control information in the accompanying data that, when it takes the activation value, is used to put the first agent into an active state. Its sources include the front-end activation signal (corresponding to the first activation signal) injected by the group chat front-end operation interface when the user mentions the first agent, and the second activation signal carried by the second agent when forwarding messages to the first agent.

[0071] Based on the above implementation methods, in some implementation methods, the activation signal is a signal used to instruct the first agent to generate a response, including a first activation signal or a second activation signal.

[0072] In this implementation, "mention" means that the user names the first intelligent agent in the message.

[0073] The second agent is another agent that forwards or delegates messages to the first agent and carries a second activation signal (i.e., a delegation pass-through signal) in the message's accompanying data. Examples include a team agent or agents in other projects. Relative to the first agent, the second agent is an upstream forwarder: it sends the message along with the second activation signal to the first agent. When a user mentions the first agent, the accompanying data of the aforementioned message carries the first activation signal. When the second agent forwards a message to the first agent, the accompanying data of the aforementioned message carries the second activation signal. Both signals are activation signals with activation values, and both proceed to step S104, determining the response state as active, thereby overriding the stored silent state that can be read in step S106.

[0074] In other words, the second agent is not the first agent itself, but rather an upstream forwarder relative to the first agent. The second activation signal carried during forwarding is used to forcibly overwrite the stored silent state and enter the active state on the first agent's side. Conversely, the target agent, as described below, is a downstream forwarded entity relative to the first agent: when a user mentions the target agent, the first agent forwards the request and necessary context to it and writes the activation signal. It should be noted that the second agent and the target agent are distinguished by their roles relative to the first agent, not by their status as fixed entities; the same entity may play different roles in different rounds—for example, a team agent acts as the second agent when forwarding messages to the first agent in round A, and as the target agent when being assigned a task by the first agent in round B; however, in this specification, the second agent refers to the upstream forwarder, and the target agent specifically refers to the downstream forwarded entity.

[0075] If only mentions by users (i.e., human members in a group chat session) are considered activation signals, messages forwarded by the second agent requesting processing from the first agent will enter step S106 due to the lack of a first activation signal, and may remain silent without generating a reply. By including the second activation signal, forwarded messages can also enter an active state.

[0076] Figure 3 This is a schematic diagram of a process for separating text content and accompanying data and detecting activation signals according to one embodiment of the present disclosure.

[0077] refer to Figure 3 Based on the above embodiments, in some embodiments, the group chat control method of this disclosure further includes: S202, The first intelligent agent separates the text content and accompanying data from the message; S204. Detect whether the accompanying data carries the first activation signal or the second activation signal.

[0078] In this implementation, the text content is the text in the session message that needs to be written into the session context and handed over to the model to generate a response when the session is active. Attached data is carried separately from the text content.

[0079] In step S204, the first agent detects whether the accompanying data contains a first activation signal or a second activation signal. If either one is present, step S104, as described above, determines the response state as active. If no activation signal is present, the process proceeds to step S106.

[0080] In this implementation, the text to be saved in the same message and the activation signal used to determine the activation state are not mixed up. The detection results can also distinguish whether the activation signal comes from a user mention or from a forwarding by a second agent.

[0081] Figure 4 This is a flowchart illustrating the parsing status declaration of one embodiment of this disclosure.

[0082] refer to Figure 4 In some embodiments of this disclosure, the response described above carries a status declaration. The step S110 described above, determining the next response status of the first agent based on the response, includes: S302. Parse the status declaration from the response to obtain the next response status.

[0083] In this implementation, the status declaration is the content in the reply used to indicate the next response status, indicating whether the next state is silent or active. The status declaration can be written in the structured content of the reply, using a Boolean value to indicate whether to enter a silent state, or it can be a pre-agreed flag in the reply. Parsing means reading the Boolean value or the pre-agreed flag and corresponding it to a silent or active state, rather than guessing based on the tone of the reply body.

[0084] In step S302, the response generated by the model includes a state declaration. The first agent parses the state declaration from the response to obtain the next response state, then stores the next response state according to step S110, and carries the next response state in the end signal.

[0085] Status statements are used to determine the next response status and are not considered as a separate message sent to the group chat session.

[0086] If the next response status is guessed solely based on the reply body, the tone of the body and whether a further reply is warranted are not always consistent. After the reply carries a status declaration and is parsed, the next response status stored in step S110 is consistent with the aforementioned declaration.

[0087] Figure 5 This is a schematic diagram of the process of storing the next response state according to one embodiment of the present disclosure.

[0088] refer to Figure 5 In some embodiments of this disclosure, storing the next response state in step S110 described above includes: S402. Using the session identifier as the key, replace the stored response state of the first agent with the next response state.

[0089] In this embodiment, the key is a session identifier used to locate the corresponding record of the aforementioned group chat session during storage. Replacement means that the current next response status overwrites the original response status on the key, rather than leaving two valid response statuses side by side under the same key.

[0090] In step S402, the first agent writes the next response state determined in step S110 to the response state storage (i.e., coordination state storage) corresponding to the aforementioned session identifier. Before the aforementioned storage is written again, when subsequent messages in the aforementioned group chat session execute step S106, the value read using the same session identifier is the value after this replacement. Different group chat sessions have different session identifiers, and the response states will not be written to the same storage record. If this replacement fails, the return of the already generated reply is not interrupted, nor is the sending of the end signal interrupted.

[0091] Therefore, the next response status can be left for subsequent messages, and only the latest response status of the above session will be obtained in the same read.

[0092] Figure 6 This is a schematic diagram of signaling forwarded to a target intelligent agent according to one embodiment of this disclosure.

[0093] refer to Figure 6 From left to right, the diagram shows a human member, the first agent, and the target agent. The human member sends a message mentioning the target agent to the first agent. The first agent sends the request from the message that the target agent needs to handle (e.g., the specific task the user requests the target agent to complete) along with the necessary context to the target agent, and includes an activation signal in the attached data of this message. Based on the activation signal, the target agent determines its own response state to be active.

[0094] In this implementation, the relationship between the first agent and the target agent is distinguished by mention type (i.e., route identification, which falls under the responsibility of the planning module): When an activation mention points to the first agent itself, the first agent directly generates a response according to step S110 and does not forward it to other agents; when a delegation mention points to the target agent (e.g., a team agent from another project), the first agent must forward the request along with the necessary context to the target agent and write an activation signal in the attached data of the forwarding message to force the target agent into an active state. The target agent is the object to which the user mention points, and the first agent forwards the request and necessary context and writes the activation signal. It is the downstream recipient of the forwarded message relative to the first agent, not the first agent itself. In conjunction with the above, the second agent is the upstream forwarder relative to the first agent, and the target agent is the downstream recipient of the forwarded message relative to the first agent; the roles of the two can be played alternately by the same entity in different rounds, but the terminology is distinguished according to the roles.

[0095] refer to Figure 6 Based on the above embodiments, in some embodiments, the group chat control method of this disclosure further includes: In response to the mention in the message that refers to the target agent rather than the first agent, the first agent forwards the request and necessary context to the target agent and writes an activation signal in the accompanying data of the forwarded message so that the target agent can determine the target agent's response state as active.

[0096] In this embodiment, referring to a target agent means that the object mentioned in the message is the target agent, not the first agent. The request is the task or problem content in the message that the target agent needs to handle. The necessary context is the content taken from the current session context that the target agent needs to process the request; for example, previous dialogue related to the task in the session context, user-confirmed constraints, or given key parameters, etc., are forwarded to the target agent by the first agent, so that the target agent can understand the task background without relying on a single forwarded message.

[0097] In this embodiment, an activation signal is written into the attached data of the forwarded message. This activation signal is placed in the attached data of the message forwarded to the target agent, so that the target agent can determine its own response state as active.

[0098] In this embodiment, the first agent first examines the referenced object of the message. If the referenced object is the first agent itself, it does not forward the message and still generates a reply according to step S110. If the referenced object is the target agent, the first agent does not keep the request locally as a question to be answered, but forwards the request and necessary context to the target agent and writes an activation signal in the attached data of the forwarded message.

[0099] If a response is also generated by the first agent to a reference directed at the target agent, the response will be irrelevant.

[0100] If an activation signal is not written during forwarding, the target agent will process the message as if it did not carry an activation signal, and may remain silent and not generate a reply. This implementation enables the target agent to enter an active state and process the request by having the first agent forward the request and necessary context and write an activation signal.

[0101] Figure 7 This is a schematic diagram of the process of generating a response using a call model according to one embodiment of this disclosure.

[0102] refer to Figure 7 In some embodiments of this disclosure, the step S110 described above, which calls the model to generate a response, includes: S602. Construct the input of the model using the session context, the message, and the callback tool declaration; S604. Invoke the model to generate a response based on the input.

[0103] In this implementation, the callback tool declaration is a tool description placed in the model input, used to declare to the model the callable tools. The callback tool declaration is not a response body, nor does it replace the session context.

[0104] In step S602, the first agent takes the already written session context, the current message, and the callback tool declaration together to form the input of the model.

[0105] In step S604, the first agent invokes the model, which generates a response based on the inputs described above.

[0106] If the current message is only given to the model without the session context, the model's response will lack previously written dialogue. Without callback tool declarations, the model cannot determine which tools to invoke.

[0107] Therefore, this model call in the active state simultaneously sees the session context, the current message, and the callable tools, making the generated response consistent with the accumulated dialogue.

[0108] Figure 8 This is a schematic diagram of a round declaration tool according to one embodiment of this disclosure.

[0109] refer to Figure 8 Based on the above implementation methods, in some implementation methods, the callback tool declaration includes a declaration of a round declaration tool (i.e., a virtual round declaration tool), which is a tool that is not executed.

[0110] In some implementations, the model invokes the round declaration tool when generating a response, and the parameters invoked indicate the next response state of the first agent. In this implementation, the parameters invoked are the enter_ghost parameter of the round declaration tool, which indicates whether the next response state of the first agent is a silent state or an active state.

[0111] In this implementation, the round declaration tool is an item in the callback tool declaration. When the model generates a response, it can call the round declaration tool and provide the enter silence parameter (enter_ghost). The first agent does not execute the round declaration tool, nor does it treat this call as an operation to be performed externally.

[0112] The "Enter Silence" parameter only indicates whether the next response state is silent or active. When the "Enter Silence" parameter is true, the next response state is silent. When the "Enter Silence" parameter is false, the next response state is active.

[0113] If the model does not call the above round declaration tool, or does not provide the enter silence parameter when calling it, the next response state will be determined as silent.

[0114] The model provides a parameter for entering silence, which can be correlated with the content of the response. If the response is a conclusive answer, a completed forwarding, or merely a notification, the parameter for entering silence is true, indicating that the next response state is silent.

[0115] If the response includes follow-up questions to the user, waiting for the forwarding result, or the step-by-step processing is not yet complete, then the silence parameter is false, indicating that the next response state is active.

[0116] When the first agent examines the tool calls provided by the model, it identifies the round declaration tool (i.e., intercepts the virtual round declaration tool during the parsing phase), reads the entry silence parameter (enter_ghost) of the aforementioned round declaration tool, obtains the next response status, and does not add the aforementioned round declaration tool to the list of tools to be executed. In this embodiment, the round declaration tool, along with tools such as updating to-do lists and delivering results, belongs to the same set of virtual tools and is not actually executed; the round declaration tool only contains parameter definitions and is read-only, and its execution body is not called. If the model also provides other tool calls that do not belong to the aforementioned set of virtual tools, those tool calls are still added to the list of tools to be executed and executed as usual.

[0117] In this embodiment, the obtained next response status is still stored according to step S110, and an end signal is written.

[0118] In this way, the next response status is specified by the model using parameters in this response. The round declaration tool itself does not generate any additional execution actions; declaring the next response status does not become a real tool operation.

[0119] In some implementations, if the response does not include a status declaration (i.e., the declaration is omitted), the next response status is determined to be silent (default silent).

[0120] As described above, when the model's response carries a state declaration, the state declaration is parsed from the model's response to obtain the next response state.

[0121] This implementation addresses the case where the model's response lacks a status declaration. A status declaration is content in the response used to indicate the next response status.

[0122] Step S110 described above in this disclosure requires determining the next response state based on the model's response. When the model's response does not contain a state declaration (i.e., an omission declaration), the first agent does not keep the next response state as an active state, nor does it make any further guesses. Instead, it determines the next response state as a silent state (default silent), stores it according to step S110, and carries the silent state in the end signal.

[0123] If the model does not provide a next response state, it defaults to a silent state to prevent the first agent from generating responses to subsequent messages when a state declaration is missing.

[0124] In some implementations, the first agent that processes the session messages is an instance instantiated in response to receiving a message. The instance is destroyed after returning the reply to the group chat session. The stored response state of the first agent is retained after the instance is destroyed, and can be read by instances that process subsequent messages in the group chat session.

[0125] In this implementation, the first agent logically remains the coordinating AI participant in the aforementioned group chat session; in practice, it is a coordinating AI participant object instantiated by the server to process group chat messages. In a stateless architecture (e.g., based on a server-side push stream (SSE) interface), each time the message access layer receives a group chat message, a new first agent object is instantiated to handle the message; this object is the instance that processes the message. Therefore, "one first agent" refers to a logical role with one instance; "one instance per message" refers to the runtime object count increasing with each message, and these are not the same thing.

[0126] In this embodiment, an instance is a newly created first agent object run by the message access layer to process this message. Destruction means that the first agent object run ends, and the runtime data (such as temporary variables of the current request and intermediate results that are not externally persisted) that was only stored in the object's memory during the current run is not left for the next session message. The destruction described in this embodiment occurs after returning a reply to the group chat session, corresponding to step S110.

[0127] Each time the message access layer receives a message, it instantiates a first agent object for that message. The instance executing step S110 is destroyed after returning a reply. The reply state is externally stored with the session identifier as the key and does not disappear with the instance. When the next message arrives, the new instance executes step S106 and reads the still-retained reply state using the same session identifier.

[0128] If the response state remains only in the current instance, after the instance is destroyed, subsequent messages will not be able to read the response state from the previous round. Step S106 will enter a silent state as if it was not read, and the active state cannot be continued. If the response state is retained after the instance is destroyed, subsequent messages can read the silent or active state that was determined in the previous round.

[0129] In some implementations, the termination signal described above is used to allow the front end to switch the display state of the first intelligent agent.

[0130] In this embodiment, the front end is the group chat front-end operation interface or display layer, responsible for showing the user the response status of the first intelligent agent, rather than a business front end like a fund management system. The display status is the display effect that the user can see on the aforementioned group chat front-end operation interface, corresponding to the silent or active state; for example, clearing the prompt that a reply is being generated based on the end signal, or switching the status identifier of the first intelligent agent to silent or active.

[0131] The end signal sent in step S108 carries a silent state. The end signal sent in step S110 carries the next response state. The group chat front-end operation interface switches the display state of the first agent according to the state carried by the end signal, instead of guessing whether the first agent is still generating a reply. The display on the group chat front-end operation interface is consistent with the end signal sent this time.

[0132] In some embodiments, the group chat control method disclosed herein further includes: After the termination signal is sent, the compression of the session context is triggered asynchronously.

[0133] In this implementation, compression means reducing the length of the session context. Asynchronous means that compression does not consume the waiting time for sending an end signal and returning a reply.

[0134] Both steps S108 and S110 will send an end signal. After the end signal is sent, compression of the session context can be triggered. Compression can be performed in an asynchronous task separate from the return path of this request, without blocking the end signal or the reply already returned in step S110.

[0135] As the session context continues to grow due to the continuous writing in step S102, the length of the session context is reduced by the above asynchronous compression, thereby avoiding the impact of excessively long context on subsequent processing, and without prolonging the return latency of this message.

[0136] In some implementations, the stored response status is not limited to a single record with the session identifier as the key. It can also be written to a row in the database corresponding to the aforementioned session, or to the metadata field of the session, or as a record with an expiration date. Alternatively, the response status from the previous round can be included in subsequent messages and not stored centrally. Regardless of where it is stored, subsequent messages must be able to retrieve the silent or active state left from the previous round according to the aforementioned group chat session.

[0137] In some implementations, the model does not use a round declaration tool to declare the next response state. The model can provide a boolean value indicating whether to enter a silent state in the structured content of the response, or it can provide a pre-agreed flag in the response, or it can make another call to determine only the next response state outside of generating this response, and use the result of this call to determine the silent state or the active state.

[0138] In other implementations, session messages are delivered via a persistent connection or processed after being retrieved from the message queue, eliminating the need to create a new run for each received message. Regardless of how messages are delivered, the silent state still skips model calls, the active state still determines the next response state, and the silent or active state is left according to the group chat session.

[0139] In another implementation, an activation source identifier can be introduced: automatically forwarded messages set the above identifier to no, direct naming or explicit calls set it to yes, and the default is yes; when passively activated (identified as no), the first agent can observe silently for several rounds before deciding whether to speak, and the number of rounds can be obtained by the number of consecutive textless model rounds at the end of the conversation history (the above counting is a prompt word layer strategy, which is completed by the model reading the history and does not require an external counter).

[0140] Figure 9 This is a schematic diagram of the system architecture of a group chat control method according to one embodiment of this disclosure. (Reference) Figure 9The message access layer receives group chat messages statelessly (e.g., via the server-pushed stream SSE interface). For each request, a first agent object is instantiated, and the message is written to the session context (i.e., context accumulation). The response state for this round is determined according to steps S104 and S106 (i.e., resolved by the coordination state resolution module according to a three-level priority: front-end activation signals take precedence over delegation pass-through signals, and delegation pass-through signals take precedence over the response state storage with the session identifier as the key (i.e., coordination state storage); the default is silent state). The silent / activation branch decision (i.e., silent decision) is established when the execution mode is group chat and the response state is silent. In this case, model calls are skipped (i.e., zero-model inference), and the process proceeds directly to the end signal. The silent state is persisted; when the response state is active, the model is invoked to generate a reply and determine whether to forward it (i.e., enter the planning module, including model and route identification). The model declares the next response state through the round declaration tool (i.e., the virtual round declaration tool, end_turn, with the parameter enter_ghost to enter the silent state). The first agent intercepts the above virtual tool during the parsing phase and removes it from the list of real executable tools. After calculating the next response state, the end signal sending module sends an end signal carrying the response state field and stores the next response state (i.e., write back to the coordination state / write back to the coordination state storage). Optionally, session context compression is triggered asynchronously after the end signal. The above module division is used to illustrate the data flow and responsibility boundaries of this embodiment, corresponding to steps S102 to S110.

[0141] The following example, using a specific group chat session, illustrates a connection between steps S102 to S110 and the related steps mentioned above.

[0142] Figure 10 This is a timing diagram illustrating the multi-round connection between silent and active states in one embodiment of this disclosure. (Reference) Figure 10 When a human member first sends a normal message, the first agent reads the response state (i.e., the coordination state) as silent (or default silent), sends an end signal carrying the silent state, and skips model calls (i.e., zero-model inference). Subsequently, the user mentions the first agent, the group chat front-end operation interface injects a front-end activation signal, overwriting the already persisted silent state, the first agent enters the active state and calls the model to generate a reply; at the end of the reply, the model calls the round declaration tool (i.e., the virtual round declaration tool) and when the silent parameter is true, it stores the next response state as silent (i.e., writes back to the coordination state) and sends an end signal; when the next normal message arrives, the new instance reads the already written-back silent state and skips model calls again (i.e., zero-model inference again). This demonstrates the external persistence of response states across stateless requests, and the default silence as a fallback.

[0143] In a group chat session, a human member (user) first sends a normal message. This normal message does not carry an activation signal, and the session identifier for the group chat session has not yet stored a response state. The first agent executes step S102, writing the normal message into the session context; executes step S106, determining the response state as silent; executes step S108, skipping model invocation (i.e., zero-model inference), not generating a reply, storing the silent state, and sending an end signal carrying the silent state. The group chat front-end interface can switch the first agent's display state to the display corresponding to the silent state based on the end signal.

[0144] Next, the user mentions the first agent in the next message, with accompanying data carrying a first activation signal. The first agent executes steps S202 and S204, separating the text content and accompanying data from the message and detecting the first activation signal. The first agent executes step S104, determining the response state as active, and then executes steps S602 and S604, using the session context, the aforementioned message, and callback tool declaration to construct the model's input, and calling the model to generate a response.

[0145] When determining the next response status, at least one of the following methods can be used.

[0146] One approach is to include a callback tool declaration that includes a round declaration tool declaration. When the model generates a response, it calls the aforementioned tool. The first agent reads the parameters of the call to obtain the next response status and does not execute the aforementioned tool.

[0147] Another approach is as follows: When the reply includes a status declaration, step S302 is executed to parse the status declaration from the reply; when the reply does not include a status declaration, the next response status is determined to be silent. The first agent then executes step S402, replacing the stored response status with the aforementioned session identifier as the key, returning a reply to the group chat session, and sending an end signal carrying the next response status. The instance that processed the above message is destroyed after returning the reply, and the stored response status is still available for subsequent message instances to read.

[0148] After the end signal is sent, the steps for asynchronously compressing the session context described above can be executed.

[0149] If another message refers to the target agent instead of the first agent, the first agent forwards the request and necessary context to the target agent and writes an activation signal in the attached data of the forwarded message, so that the target agent can determine the target agent's response state as active.

[0150] Figure 11 This is a schematic diagram illustrating the transition of a first agent's response state (i.e., coordinated state; silent state / active state) according to one embodiment of this disclosure. (See reference) Figure 11 The default response state of the first agent is silent. When in silent state, ordinary messages are still written to the session context (i.e., context accumulation) but the model is not invoked (i.e., zero model). When the attached data carries the front-end activation signal or the delegation pass-through signal (i.e., the second activation signal / the activation signal of cross-agent delegation pass-through, with the value being the activation value), it transitions from silent state to active state. When in active state, if the model invokes the round declaration tool (i.e., the virtual round declaration tool) and the enter silence parameter is true, or the model omits a declaration (default silence), the next response state is silent. If the enter silence parameter is false, the next response state remains active.

[0151] The subject executing the group chat control method in the specific embodiments of this disclosure can be an electronic device such as a mobile phone or computer.

[0152] Therefore, based on any of the above embodiments, this disclosure also provides an electronic device that can execute the group chat control method of any of the embodiments described above.

[0153] Figure 12 This is a schematic block diagram of an electronic device 1000 according to one embodiment of the present disclosure.

[0154] The hardware architecture of the electronic device 1000 can be implemented using a bus architecture. The bus architecture can include any number of interconnect buses and bridges, depending on the specific application of the hardware and overall design constraints. Bus 1100 connects various circuits, including one or more processors 1200, memory 1300, and / or hardware modules. Bus 1100 can also connect various other circuits 1400, such as peripheral devices, voltage regulators, power management circuits, external antennas, etc.

[0155] Bus 1100 can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of representation, only one connection line is used in the above diagram, but this does not imply that there is only one bus or one type of bus.

[0156] This disclosure also provides a readable storage medium storing a computer program that, when executed by a processor, is used to implement the methods described above. The readable storage medium can be any means capable of containing, storing, communicating, propagating, or transmitting a program for use by or in conjunction with an instruction execution system, apparatus, or device. More specific examples of readable storage media include: an electrical connection portion (electronic device) having one or more wires, a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), fiber optic device, and portable read-only memory (CDROM), etc.

[0157] This disclosure also provides a computer program product, the methods of which can be implemented wholly or partially through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented wholly or partially as a computer program product. The computer program product includes one or more computer programs or instructions. When the computer program or instructions are loaded and executed, all or part of the processes or functions of this disclosure are performed.

[0158] Computer programs or instructions can be stored in a readable storage medium or transferred from one readable storage medium to another. For example, the computer program or instructions can be transferred from one website, computer, server, or data center to another website, computer, server, or data center via wired or wireless means. A readable storage medium can be any available medium capable of access, or a data storage device such as a server or data center that integrates one or more available media. Available media can be magnetic media, such as floppy disks, hard disks, and magnetic tapes; optical media, such as digital video discs; or semiconductor media, such as solid-state drives. The aforementioned computer-readable storage media can be volatile or non-volatile, or may include both types.

[0159] Those skilled in the art will understand that embodiments of this disclosure can be provided as methods, systems, or computer program products. Therefore, this disclosure can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this disclosure can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0160] This disclosure is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to this disclosure. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0161] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, the instruction means being implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0162] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0163] In the description of this specification, the references to the terms "an embodiment / mode," "some embodiments / modes," "example," "specific example," or "some examples," etc., refer to specific features, structures, or characteristics described in connection with the above embodiments / modes or examples, which are included in at least one embodiment / mode or example of this disclosure. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment / mode or example. Moreover, the specific features, structures, or characteristics described may be combined in any suitable manner in one or more embodiments / modes or examples. Furthermore, without contradiction, those skilled in the art can combine and integrate the different embodiments / modes or examples described in this specification, as well as the features of different embodiments / modes or examples.

[0164] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of the aforementioned features. In the description of this disclosure, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0165] Those skilled in the art should understand that the above embodiments are merely for illustrating the present disclosure and are not intended to limit the scope of the disclosure. Those skilled in the art can make other changes or modifications based on the above disclosure, and these changes or modifications still fall within the scope of the present disclosure.

Claims

1. A group chat control method, applied to a first intelligent agent, characterized in that, include: In response to receiving a message in a group chat session, the message is written into the session context; In response to the activation signal carried by the accompanying data of the message, the response state of the first agent is determined to be active. In response to the fact that the accompanying data does not carry the activation signal, the stored response state is read using the session identifier of the group chat session. When a silent state or an active state is read, it is determined as the response state of the first agent. When reading fails, an illegal value is read, or no value is read, the response state of the first agent is determined as a silent state. In response to the silence state, skip the model call, do not generate a reply, store the silence state, and send an end signal carrying the silence state. In response to the active state of the response, the model is invoked to generate a reply, the next response state of the first agent is determined based on the reply, the next response state is stored, the reply is returned to the group chat session, and an end signal carrying the next response state is sent.

2. The group chat control method according to claim 1, characterized in that, The activation signal is a signal used to instruct the first agent to generate a response, including a first activation signal or a second activation signal.

3. The group chat control method according to claim 2, characterized in that, The first activation signal is the activation signal carried in the accompanying data when the user mentions the first agent in the group chat session, and the second activation signal is the activation signal carried in the accompanying data when the second agent forwards a message to the first agent.

4. The group chat control method according to claim 3, characterized in that, The method further includes: The first agent separates the text content from the message and the accompanying data, and detects whether the accompanying data carries the first activation signal or the second activation signal.

5. The group chat control method according to claim 1, characterized in that, The response includes a status declaration, which indicates the status of the next response. Determining the next response state of the first agent based on the response includes: The status declaration is parsed from the response to obtain the next response status.

6. The group chat control method according to claim 1, characterized in that, The step of storing the next response status includes: Using the session identifier as the key, the stored response state of the first agent is replaced with the next response state.

7. The group chat control method according to claim 1, characterized in that, The method further includes: In response to the mention in the message that points to the target agent rather than the first agent, the first agent forwards the request and necessary context to the target agent and writes an activation signal in the attached data of the forwarded message so that the target agent can determine the target agent's response state as active. Optionally, the calling model generates a response, including: The input to the model is constructed using the session context, the message, and the callback tool declaration. The model is then invoked to generate a response based on the input. The callback tool declaration is used to declare callable tools to the model. Optionally, the callback tool declaration includes a declaration of a round declaration tool, wherein the round declaration tool is a tool that is not executed; Optionally, when the model generates a response, it calls the round declaration tool, and the parameters called are used to indicate the next response state of the first agent; Optionally, if the response does not include a status declaration, the next response status is determined to be silent. Optionally, the first agent that processes the message is an instance that is instantiated in response to receiving the message. The instance is destroyed after returning the reply to the group chat session. The stored response state of the first agent is retained after the instance is destroyed, so that the instance that processes subsequent messages in the group chat session can read it. Optionally, the termination signal is used to allow the front end to switch the display state of the first intelligent agent; Optionally, the method further includes: After the termination signal is sent, the compression of the session context is triggered asynchronously.

8. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the group chat control method according to any one of claims 1 to 7.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the steps of the group chat control method according to any one of claims 1 to 7.

10. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the group chat control method according to any one of claims 1 to 7.