ben/coze-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(singleagent): support workflow output node (#662)

Browse Source
This commit is contained in:
junwen-lee
2025-08-11 10:49:51 +08:00
committed by GitHub
parent a21e41b89d
commit efc6e55fe5
18 changed files with 391 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
backend/domain/conversation/agentrun/entity/run_record.go
View File

@@ -141,15 +141,17 @@ type AgentRunResponse struct {
}
type AgentRespEvent struct {
EventType message.MessageType
EventType message.MessageType `json:"event_type"`
ModelAnswer *schema.StreamReader[*schema.Message]
ToolsMessage []*schema.Message
FuncCall *schema.Message
Suggest *schema.Message
Knowledge []*schema.Document
Interrupt *singleagent.InterruptInfo
Err error
ToolMidAnswer *schema.StreamReader[*schema.Message]
ToolAsAnswer *schema.StreamReader[*schema.Message]
ModelAnswer *schema.StreamReader[*schema.Message]
ToolsMessage []*schema.Message
FuncCall *schema.Message
Suggest *schema.Message
Knowledge []*schema.Document
Interrupt *singleagent.InterruptInfo
Err error
}
type ModelAnswerEvent struct {

296
backend/domain/conversation/agentrun/service/agent_run_impl.go
View File

@@ -203,8 +203,12 @@ func transformEventMap(eventType singleagent.EventType) (message.MessageType, er
return message.MessageTypeKnowledge, nil
case singleagent.EventTypeOfToolsMessage:
return message.MessageTypeToolResponse, nil
case singleagent.EventTypeOfChatModelAnswer, singleagent.EventTypeOfToolsAsChatModelStream:
case singleagent.EventTypeOfChatModelAnswer:
return message.MessageTypeAnswer, nil
case singleagent.EventTypeOfToolsAsChatModelStream:
return message.MessageTypeToolAsAnswer, nil
case singleagent.EventTypeOfToolMidAnswer:
return message.MessageTypeToolMidAnswer, nil
case singleagent.EventTypeOfSuggest:
return message.MessageTypeFlowUp, nil
case singleagent.EventTypeOfInterrupt:
@@ -241,12 +245,12 @@ func (c *runImpl) buildAgentMessage2Create(ctx context.Context, chunk *entity.Ag
buildExt = arm.Ext
msg.DisplayContent = arm.DisplayContent
case message.MessageTypeAnswer:
case message.MessageTypeAnswer, message.MessageTypeToolAsAnswer:
msg.Role = schema.Assistant
msg.ContentType = message.ContentTypeText
case message.MessageTypeToolResponse:
msg.Role = schema.Tool
msg.Role = schema.Assistant
msg.ContentType = message.ContentTypeText
msg.Content = chunk.ToolsMessage[0].Content
@@ -261,7 +265,7 @@ func (c *runImpl) buildAgentMessage2Create(ctx context.Context, chunk *entity.Ag
msg.Role = schema.Assistant
msg.ContentType = message.ContentTypeText
knowledgeContent := c.buildKnowledge(ctx, arm, chunk)
knowledgeContent := c.buildKnowledge(ctx, chunk)
if knowledgeContent != nil {
knInfo, err := json.Marshal(knowledgeContent)
if err == nil {
@@ -461,6 +465,9 @@ func (c *runImpl) pull(_ context.Context, mainChan chan *entity.AgentRespEvent,
Knowledge: rm.Knowledge,
Suggest: rm.Suggest,
Interrupt: rm.Interrupt,
ToolMidAnswer: rm.ToolMidAnswer,
ToolAsAnswer: rm.ToolAsChatModelAnswer,
}
mainChan <- respChunk
@@ -478,9 +485,12 @@ func (c *runImpl) push(ctx context.Context, mainChan chan *entity.AgentRespEvent
}()
reasoningContent := bytes.NewBuffer([]byte{})
var createPreMsg = true
var preFinalAnswerMsg *msgEntity.Message
var firstAnswerMsg *msgEntity.Message
var reasoningMsg *msgEntity.Message
isSendFinishAnswer := false
var preToolResponseMsg *msgEntity.Message
toolResponseMsgContent := bytes.NewBuffer([]byte{})
for {
chunk, ok := <-mainChan
if !ok || chunk == nil {
@@ -489,6 +499,19 @@ func (c *runImpl) push(ctx context.Context, mainChan chan *entity.AgentRespEvent
logs.CtxInfof(ctx, "hanlder event:%v,err:%v", conv.DebugJsonToStr(chunk), chunk.Err)
if chunk.Err != nil {
if errors.Is(chunk.Err, io.EOF) {
if !isSendFinishAnswer {
isSendFinishAnswer = true
if firstAnswerMsg != nil && len(reasoningContent.String()) > 0 {
c.saveReasoningContent(ctx, firstAnswerMsg, reasoningContent.String())
reasoningContent.Reset()
}
finishErr := c.handlerFinalAnswerFinish(ctx, sw, rtDependence)
if finishErr != nil {
err = finishErr
return
}
}
return
}
c.handlerErr(ctx, chunk.Err, sw)
@@ -501,45 +524,156 @@ func (c *runImpl) push(ctx context.Context, mainChan chan *entity.AgentRespEvent
if err != nil {
return
}
if preToolResponseMsg == nil {
var cErr error
preToolResponseMsg, cErr = c.PreCreateAnswer(ctx, rtDependence)
if cErr != nil {
err = cErr
return
}
}
case message.MessageTypeToolResponse:
err = c.handlerTooResponse(ctx, chunk, sw, rtDependence)
err = c.handlerTooResponse(ctx, chunk, sw, rtDependence, preToolResponseMsg, toolResponseMsgContent.String())
if err != nil {
return
}
preToolResponseMsg = nil // reset
case message.MessageTypeKnowledge:
err = c.handlerKnowledge(ctx, chunk, sw, rtDependence)
if err != nil {
return
}
case message.MessageTypeToolMidAnswer:
fullMidAnswerContent := bytes.NewBuffer([]byte{})
var usage *msgEntity.UsageExt
toolMidAnswerMsg, cErr := c.PreCreateAnswer(ctx, rtDependence)
if cErr != nil {
err = cErr
return
}
var preMsgIsFinish = false
for {
streamMsg, receErr := chunk.ToolMidAnswer.Recv()
if receErr != nil {
if errors.Is(receErr, io.EOF) {
break
}
err = receErr
return
}
if preMsgIsFinish {
toolMidAnswerMsg, cErr = c.PreCreateAnswer(ctx, rtDependence)
if cErr != nil {
err = cErr
return
}
preMsgIsFinish = false
}
if streamMsg == nil {
continue
}
if firstAnswerMsg == nil && len(streamMsg.Content) > 0 {
if reasoningMsg != nil {
toolMidAnswerMsg = deepcopy.Copy(reasoningMsg).(*msgEntity.Message)
}
firstAnswerMsg = deepcopy.Copy(toolMidAnswerMsg).(*msgEntity.Message)
}
if streamMsg.Extra != nil {
if val, ok := streamMsg.Extra["workflow_node_name"]; ok && val != nil {
toolMidAnswerMsg.Ext["message_title"] = val.(string)
}
}
sendMidAnswerMsg := c.buildSendMsg(ctx, toolMidAnswerMsg, false, rtDependence)
sendMidAnswerMsg.Content = streamMsg.Content
toolResponseMsgContent.WriteString(streamMsg.Content)
fullMidAnswerContent.WriteString(streamMsg.Content)
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, sendMidAnswerMsg, sw)
if streamMsg != nil && streamMsg.ResponseMeta != nil {
usage = c.handlerUsage(streamMsg.ResponseMeta)
}
if streamMsg.Extra["is_finish"] == true {
preMsgIsFinish = true
sendMidAnswerMsg := c.buildSendMsg(ctx, toolMidAnswerMsg, false, rtDependence)
sendMidAnswerMsg.Content = fullMidAnswerContent.String()
fullMidAnswerContent.Reset()
hfErr := c.handlerAnswer(ctx, sendMidAnswerMsg, sw, usage, rtDependence, toolMidAnswerMsg)
if hfErr != nil {
err = hfErr
return
}
}
}
case message.MessageTypeToolAsAnswer:
var usage *msgEntity.UsageExt
fullContent := bytes.NewBuffer([]byte{})
toolAsAnswerMsg, cErr := c.PreCreateAnswer(ctx, rtDependence)
if cErr != nil {
err = cErr
return
}
if firstAnswerMsg == nil {
firstAnswerMsg = toolAsAnswerMsg
}
for {
streamMsg, receErr := chunk.ToolAsAnswer.Recv()
if receErr != nil {
if errors.Is(receErr, io.EOF) {
answer := c.buildSendMsg(ctx, toolAsAnswerMsg, false, rtDependence)
answer.Content = fullContent.String()
hfErr := c.handlerAnswer(ctx, answer, sw, usage, rtDependence, toolAsAnswerMsg)
if hfErr != nil {
err = hfErr
return
}
break
}
err = receErr
return
}
if streamMsg != nil && streamMsg.ResponseMeta != nil {
usage = c.handlerUsage(streamMsg.ResponseMeta)
}
sendMsg := c.buildSendMsg(ctx, toolAsAnswerMsg, false, rtDependence)
fullContent.WriteString(streamMsg.Content)
sendMsg.Content = streamMsg.Content
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, sendMsg, sw)
}
case message.MessageTypeAnswer:
fullContent := bytes.NewBuffer([]byte{})
var usage *msgEntity.UsageExt
var isToolCalls = false
var modelAnswerMsg *msgEntity.Message
for {
streamMsg, receErr := chunk.ModelAnswer.Recv()
if receErr != nil {
if errors.Is(receErr, io.EOF) {
if isToolCalls {
break
}
finalAnswer := c.buildSendMsg(ctx, preFinalAnswerMsg, false, rtDependence)
finalAnswer.Content = fullContent.String()
finalAnswer.ReasoningContent = ptr.Of(reasoningContent.String())
hfErr := c.handlerFinalAnswer(ctx, finalAnswer, sw, usage, rtDependence, preFinalAnswerMsg)
if modelAnswerMsg == nil {
break
}
answer := c.buildSendMsg(ctx, modelAnswerMsg, false, rtDependence)
answer.Content = fullContent.String()
hfErr := c.handlerAnswer(ctx, answer, sw, usage, rtDependence, modelAnswerMsg)
if hfErr != nil {
err = hfErr
return
}
finishErr := c.handlerFinalAnswerFinish(ctx, sw, rtDependence)
if finishErr != nil {
err = finishErr
return
}
break
}
err = receErr
@@ -557,32 +691,64 @@ func (c *runImpl) push(ctx context.Context, mainChan chan *entity.AgentRespEvent
if streamMsg != nil && len(streamMsg.ReasoningContent) == 0 && len(streamMsg.Content) == 0 {
continue
}
if createPreMsg && (len(streamMsg.ReasoningContent) > 0 || len(streamMsg.Content) > 0) {
preFinalAnswerMsg, err = c.PreCreateFinalAnswer(ctx, rtDependence)
if err != nil {
return
if len(streamMsg.ReasoningContent) > 0 {
if reasoningMsg == nil {
reasoningMsg, err = c.PreCreateAnswer(ctx, rtDependence)
if err != nil {
return
}
}
createPreMsg = false
sendReasoningMsg := c.buildSendMsg(ctx, reasoningMsg, false, rtDependence)
reasoningContent.WriteString(streamMsg.ReasoningContent)
sendReasoningMsg.ReasoningContent = ptr.Of(streamMsg.ReasoningContent)
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, sendReasoningMsg, sw)
}
if len(streamMsg.Content) > 0 {
sendMsg := c.buildSendMsg(ctx, preFinalAnswerMsg, false, rtDependence)
reasoningContent.WriteString(streamMsg.ReasoningContent)
sendMsg.ReasoningContent = ptr.Of(streamMsg.ReasoningContent)
if modelAnswerMsg == nil {
modelAnswerMsg, err = c.PreCreateAnswer(ctx, rtDependence)
if err != nil {
return
}
if firstAnswerMsg == nil {
if reasoningMsg != nil {
modelAnswerMsg.ID = reasoningMsg.ID
}
firstAnswerMsg = modelAnswerMsg
}
}
fullContent.WriteString(streamMsg.Content)
sendMsg.Content = streamMsg.Content
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, sendMsg, sw)
sendAnswerMsg := c.buildSendMsg(ctx, modelAnswerMsg, false, rtDependence)
fullContent.WriteString(streamMsg.Content)
sendAnswerMsg.Content = streamMsg.Content
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, sendAnswerMsg, sw)
}
}
case message.MessageTypeFlowUp:
if isSendFinishAnswer {
if firstAnswerMsg != nil && len(reasoningContent.String()) > 0 {
c.saveReasoningContent(ctx, firstAnswerMsg, reasoningContent.String())
}
isSendFinishAnswer = true
finishErr := c.handlerFinalAnswerFinish(ctx, sw, rtDependence)
if finishErr != nil {
err = finishErr
return
}
}
err = c.handlerSuggest(ctx, chunk, sw, rtDependence)
if err != nil {
return
}
case message.MessageTypeInterrupt:
err = c.handlerInterrupt(ctx, chunk, sw, rtDependence)
err = c.handlerInterrupt(ctx, chunk, sw, rtDependence, firstAnswerMsg, reasoningContent.String())
if err != nil {
return
}
@@ -590,12 +756,22 @@ func (c *runImpl) push(ctx context.Context, mainChan chan *entity.AgentRespEvent
}
}
func (c *runImpl) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespEvent, sw *schema.StreamWriter[*entity.AgentRunResponse], rtDependence *runtimeDependence) error {
func (c *runImpl) saveReasoningContent(ctx context.Context, firstAnswerMsg *msgEntity.Message, reasoningContent string) {
_, err := crossmessage.DefaultSVC().Edit(ctx, &message.Message{
ID: firstAnswerMsg.ID,
ReasoningContent: reasoningContent,
})
if err != nil {
logs.CtxInfof(ctx, "save reasoning content failed, err: %v", err)
}
}
func (c *runImpl) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespEvent, sw *schema.StreamWriter[*entity.AgentRunResponse], rtDependence *runtimeDependence, firstAnswerMsg *msgEntity.Message, reasoningCOntent string) error {
interruptData, cType, err := c.parseInterruptData(ctx, chunk.Interrupt)
if err != nil {
return err
}
preMsg, err := c.PreCreateFinalAnswer(ctx, rtDependence)
preMsg, err := c.PreCreateAnswer(ctx, rtDependence)
if err != nil {
return err
}
@@ -616,8 +792,10 @@ func (c *runImpl) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespE
c.runEvent.SendMsgEvent(entity.RunEventMessageDelta, deltaAnswer, sw)
finalAnswer := deepcopy.Copy(deltaAnswer).(*entity.ChunkMessageItem)
err = c.handlerFinalAnswer(ctx, finalAnswer, sw, nil, rtDependence, preMsg)
if len(reasoningCOntent) > 0 && firstAnswerMsg == nil {
finalAnswer.ReasoningContent = ptr.Of(reasoningCOntent)
}
err = c.handlerAnswer(ctx, finalAnswer, sw, nil, rtDependence, preMsg)
if err != nil {
return err
}
@@ -626,11 +804,6 @@ func (c *runImpl) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespE
if err != nil {
return err
}
err = c.handlerFinalAnswerFinish(ctx, sw, rtDependence)
if err != nil {
return err
}
return nil
}
@@ -733,7 +906,7 @@ func (c *runImpl) handlerErr(_ context.Context, err error, sw *schema.StreamWrit
})
}
func (c *runImpl) PreCreateFinalAnswer(ctx context.Context, rtDependence *runtimeDependence) (*msgEntity.Message, error) {
func (c *runImpl) PreCreateAnswer(ctx context.Context, rtDependence *runtimeDependence) (*msgEntity.Message, error) {
arm := rtDependence.runMeta
msgMeta := &msgEntity.Message{
ConversationID: arm.ConversationID,
@@ -765,7 +938,7 @@ func (c *runImpl) PreCreateFinalAnswer(ctx context.Context, rtDependence *runtim
return crossmessage.DefaultSVC().PreCreate(ctx, msgMeta)
}
func (c *runImpl) handlerFinalAnswer(ctx context.Context, msg *entity.ChunkMessageItem, sw *schema.StreamWriter[*entity.AgentRunResponse], usage *msgEntity.UsageExt, rtDependence *runtimeDependence, preFinalAnswerMsg *msgEntity.Message) error {
func (c *runImpl) handlerAnswer(ctx context.Context, msg *entity.ChunkMessageItem, sw *schema.StreamWriter[*entity.AgentRunResponse], usage *msgEntity.UsageExt, rtDependence *runtimeDependence, preAnswerMsg *msgEntity.Message) error {
if len(msg.Content) == 0 && len(ptr.From(msg.ReasoningContent)) == 0 {
return nil
@@ -801,12 +974,15 @@ func (c *runImpl) handlerFinalAnswer(ctx context.Context, msg *entity.ChunkMessa
if err != nil {
return err
}
preFinalAnswerMsg.Content = msg.Content
preFinalAnswerMsg.ReasoningContent = ptr.From(msg.ReasoningContent)
preFinalAnswerMsg.Ext = msg.Ext
preFinalAnswerMsg.ContentType = msg.ContentType
preFinalAnswerMsg.ModelContent = string(mc)
_, err = crossmessage.DefaultSVC().Create(ctx, preFinalAnswerMsg)
preAnswerMsg.Content = msg.Content
preAnswerMsg.ReasoningContent = ptr.From(msg.ReasoningContent)
preAnswerMsg.Ext = msg.Ext
preAnswerMsg.ContentType = msg.ContentType
preAnswerMsg.ModelContent = string(mc)
preAnswerMsg.CreatedAt = 0
preAnswerMsg.UpdatedAt = 0
_, err = crossmessage.DefaultSVC().Create(ctx, preAnswerMsg)
if err != nil {
return err
}
@@ -860,9 +1036,23 @@ func (c *runImpl) handlerAckMessage(_ context.Context, input *msgEntity.Message,
return nil
}
func (c *runImpl) handlerTooResponse(ctx context.Context, chunk *entity.AgentRespEvent, sw *schema.StreamWriter[*entity.AgentRunResponse], rtDependence *runtimeDependence) error {
func (c *runImpl) handlerTooResponse(ctx context.Context, chunk *entity.AgentRespEvent, sw *schema.StreamWriter[*entity.AgentRunResponse], rtDependence *runtimeDependence, preToolResponseMsg *msgEntity.Message, toolResponseMsgContent string) error {
cm := c.buildAgentMessage2Create(ctx, chunk, message.MessageTypeToolResponse, rtDependence)
cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
var cmData *message.Message
var err error
if preToolResponseMsg != nil {
cm.ID = preToolResponseMsg.ID
cm.CreatedAt = preToolResponseMsg.CreatedAt
cm.UpdatedAt = preToolResponseMsg.UpdatedAt
if len(toolResponseMsgContent) > 0 {
cm.Content = toolResponseMsgContent + "\n" + cm.Content
}
}
cmData, err = crossmessage.DefaultSVC().Create(ctx, cm)
if err != nil {
return err
}
@@ -902,7 +1092,7 @@ func (c *runImpl) handlerKnowledge(ctx context.Context, chunk *entity.AgentRespE
return nil
}
func (c *runImpl) buildKnowledge(_ context.Context, arm *entity.AgentRunMeta, chunk *entity.AgentRespEvent) *msgEntity.VerboseInfo {
func (c *runImpl) buildKnowledge(_ context.Context, chunk *entity.AgentRespEvent) *msgEntity.VerboseInfo {
var recallDatas []msgEntity.RecallDataInfo
for _, kOne := range chunk.Knowledge {
recallDatas = append(recallDatas, msgEntity.RecallDataInfo{

6
backend/domain/conversation/message/internal/dal/message.go
View File

@@ -241,6 +241,12 @@ func (dao *MessageDAO) messageDO2PO(ctx context.Context, msgDo *entity.Message)
UpdatedAt: time.Now().UnixMilli(),
ReasoningContent: msgDo.ReasoningContent,
}
if msgDo.CreatedAt > 0 {
msgPO.CreatedAt = msgDo.CreatedAt
}
if msgDo.UpdatedAt > 0 {
msgPO.UpdatedAt = msgDo.UpdatedAt
}
if msgDo.ModelContent != "" {
msgPO.ModelContent = msgDo.ModelContent