feat: Support for Chat Flow & Agent Support for binding a single chat flow (#765)

Co-authored-by: Yu Yang <72337138+tomasyu985@users.noreply.github.com>
Co-authored-by: zengxiaohui <csu.zengxiaohui@gmail.com>
Co-authored-by: lijunwen.gigoo <lijunwen.gigoo@bytedance.com>
Co-authored-by: lvxinyu.1117 <lvxinyu.1117@bytedance.com>
Co-authored-by: liuyunchao.0510 <liuyunchao.0510@bytedance.com>
Co-authored-by: haozhenfei <37089575+haozhenfei@users.noreply.github.com>
Co-authored-by: July <jiangxujin@bytedance.com>
Co-authored-by: tecvan-fe <fanwenjie.fe@bytedance.com>

backend/domain/workflow/internal/nodes/conversation/clearconversationhistory.go

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossconversation "github.com/coze-dev/coze-studio/backend/crossdomain/contract/conversation"
+	wf "github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type ClearConversationHistoryConfig struct{}
+
+type ClearConversationHistory struct{}
+
+func (c *ClearConversationHistoryConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeClearConversationHistory,
+		Name:    n.Data.Meta.Title,
+		Configs: c,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (c *ClearConversationHistoryConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &ClearConversationHistory{}, nil
+}
+
+func (c *ClearConversationHistory) Invoke(ctx context.Context, in map[string]any) (map[string]any, error) {
+
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+		version     = execCtx.ExeCfg.Version
+	)
+
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, query conversation list is not available"))
+	}
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("query conversation list node, app id is required"))
+	}
+
+	conversationName, ok := in["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversation name is required"))
+	}
+
+	t, existed, err := wf.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+	var conversationID int64
+	if existed {
+		ret, existed, err := wf.GetRepository().GetStaticConversationByTemplateID(ctx, env, userID, connectorID, t.TemplateID)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if existed {
+			conversationID = ret.ConversationID
+		}
+	} else {
+		ret, existed, err := wf.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if existed {
+			conversationID = ret.ConversationID
+		}
+	}
+
+	if !existed {
+		return map[string]any{
+			"isSuccess": false,
+		}, nil
+	}
+
+	resp, err := crossconversation.DefaultSVC().ClearConversationHistory(ctx, &crossconversation.ClearConversationHistoryReq{
+		ConversationID: conversationID,
+	})
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+	if resp == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, fmt.Errorf("clear conversation history failed, response is nil"))
+	}
+	if execCtx.ExeCfg.SectionID != nil {
+		atomic.StoreInt64(execCtx.ExeCfg.SectionID, resp.SectionID)
+	}
+	return map[string]any{
+		"isSuccess": true,
+	}, nil
+
+}

backend/domain/workflow/internal/nodes/conversation/conversationhistory.go

@@ -0,0 +1,190 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossconversation "github.com/coze-dev/coze-studio/backend/crossdomain/contract/conversation"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+
+	wf "github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type ConversationHistoryConfig struct{}
+
+type ConversationHistory struct{}
+
+func (ch *ConversationHistoryConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeConversationHistory,
+		Name:    n.Data.Meta.Title,
+		Configs: ch,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (ch *ConversationHistoryConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &ConversationHistory{}, nil
+}
+
+func (ch *ConversationHistory) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+		version     = execCtx.ExeCfg.Version
+		initRunID   = execCtx.ExeCfg.InitRoundID
+	)
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, query conversation list is not available"))
+	}
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("query conversation list node, app id is required"))
+	}
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversation name is required"))
+	}
+
+	rounds, ok := input["rounds"].(int64)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("rounds is required"))
+	}
+
+	template, existed, err := wf.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	var conversationID int64
+	if existed {
+		var sc *entity.StaticConversation
+		sc, existed, err = wf.GetRepository().GetStaticConversationByTemplateID(ctx, env, userID, connectorID, template.TemplateID)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if existed {
+			conversationID = sc.ConversationID
+		}
+
+	} else {
+		var dc *entity.DynamicConversation
+		dc, existed, err = wf.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if existed {
+			conversationID = dc.ConversationID
+		}
+	}
+
+	if !existed {
+		return nil, vo.WrapError(errno.ErrConversationOfAppNotFound, fmt.Errorf("the conversation name does not exist: '%v'", conversationName))
+	}
+
+	currentConversationID := execCtx.ExeCfg.ConversationID
+	isCurrentConversation := currentConversationID != nil && *currentConversationID == conversationID
+	var sectionID int64
+	if isCurrentConversation {
+		if execCtx.ExeCfg.SectionID == nil {
+			return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("section id is required"))
+		}
+		sectionID = *execCtx.ExeCfg.SectionID
+	} else {
+		cInfo, err := crossconversation.DefaultSVC().GetByID(ctx, conversationID)
+		if err != nil {
+			return nil, err
+		}
+		sectionID = cInfo.SectionID
+	}
+
+	runIDs, err := crossmessage.DefaultSVC().GetLatestRunIDs(ctx, &crossmessage.GetLatestRunIDsRequest{
+		ConversationID: conversationID,
+		UserID:         userID,
+		AppID:          *appID,
+		Rounds:         rounds,
+		InitRunID:      initRunID,
+		SectionID:      sectionID,
+	})
+
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	if len(runIDs) == 0 {
+		return map[string]any{
+			"messageList": []any{},
+		}, nil
+	}
+
+	response, err := crossmessage.DefaultSVC().GetMessagesByRunIDs(ctx, &crossmessage.GetMessagesByRunIDsRequest{
+		ConversationID: conversationID,
+		RunIDs:         runIDs,
+	})
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	var messageList []any
+	for _, msg := range response.Messages {
+		content, err := nodes.ConvertMessageToString(ctx, msg)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrConversationNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		messageList = append(messageList, map[string]any{
+			"role":    string(msg.Role),
+			"content": content,
+		})
+	}
+
+	return map[string]any{
+		"messageList": messageList,
+	}, nil
+}

backend/domain/workflow/internal/nodes/conversation/conversationlist.go

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/slices"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type ConversationList struct{}
+
+type ConversationListConfig struct{}
+
+func (c *ConversationListConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeConversationList,
+		Name:    n.Data.Meta.Title,
+		Configs: c,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (c *ConversationListConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &ConversationList{}, nil
+}
+
+type conversationInfo struct {
+	conversationName string
+	conversationId   string
+}
+
+func (c *ConversationList) Invoke(ctx context.Context, _ map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+		version     = execCtx.ExeCfg.Version
+	)
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, query conversation list is not available"))
+	}
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("query conversation list node, app id is required"))
+	}
+
+	templates, err := workflow.GetRepository().ListConversationTemplate(ctx, env, &vo.ListConversationTemplatePolicy{
+		AppID:   *appID,
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	templateIds := make([]int64, 0, len(templates))
+	for _, template := range templates {
+		templateIds = append(templateIds, template.TemplateID)
+	}
+
+	staticConversations, err := workflow.GetRepository().MGetStaticConversation(ctx, env, userID, connectorID, templateIds)
+	if err != nil {
+		return nil, err
+	}
+
+	templateIDToConvID := slices.ToMap(staticConversations, func(conv *entity.StaticConversation) (int64, int64) {
+		return conv.TemplateID, conv.ConversationID
+	})
+
+	var conversationList []conversationInfo
+
+	for _, template := range templates {
+		convID, ok := templateIDToConvID[template.TemplateID]
+		if !ok {
+			convID = 0
+		}
+		conversationList = append(conversationList, conversationInfo{
+			conversationName: template.Name,
+			conversationId:   strconv.FormatInt(convID, 10),
+		})
+	}
+
+	dynamicConversations, err := workflow.GetRepository().ListDynamicConversation(ctx, env, &vo.ListConversationPolicy{
+		ListConversationMeta: vo.ListConversationMeta{
+			APPID:       *appID,
+			UserID:      userID,
+			ConnectorID: connectorID,
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, conv := range dynamicConversations {
+		conversationList = append(conversationList, conversationInfo{
+			conversationName: conv.Name,
+			conversationId:   strconv.FormatInt(conv.ConversationID, 10),
+		})
+	}
+
+	resultList := make([]any, len(conversationList))
+	for i, v := range conversationList {
+		resultList[i] = map[string]any{
+			"conversationName": v.conversationName,
+			"conversationId":   v.conversationId,
+		}
+	}
+
+	return map[string]any{
+		"conversationList": resultList,
+	}, nil
+
+}

backend/domain/workflow/internal/nodes/conversation/createconversation.go

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/coze-dev/coze-studio/backend/api/model/conversation/common"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossconversation "github.com/coze-dev/coze-studio/backend/crossdomain/contract/conversation"
+	conventity "github.com/coze-dev/coze-studio/backend/domain/conversation/conversation/entity"
+
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type CreateConversationConfig struct{}
+
+type CreateConversation struct{}
+
+func (c *CreateConversationConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeCreateConversation,
+		Name:    n.Data.Meta.Title,
+		Configs: c,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (c *CreateConversationConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &CreateConversation{}, nil
+}
+
+func (c *CreateConversation) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+
+	var (
+		execCtx                 = execute.GetExeCtx(ctx)
+		env                     = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID                   = execCtx.ExeCfg.AppID
+		agentID                 = execCtx.ExeCfg.AgentID
+		version                 = execCtx.ExeCfg.Version
+		connectorID             = execCtx.ExeCfg.ConnectorID
+		userID                  = execCtx.ExeCfg.Operator
+		conversationIDGenerator = workflow.ConversationIDGenerator(func(ctx context.Context, appID int64, userID, connectorID int64) (*conventity.Conversation, error) {
+			return crossconversation.DefaultSVC().CreateConversation(ctx, &conventity.CreateMeta{
+				AgentID:     appID,
+				UserID:      userID,
+				ConnectorID: connectorID,
+				Scene:       common.Scene_SceneWorkflow,
+			})
+		})
+	)
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, create conversation is not available"))
+	}
+
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, errors.New("create conversation node, app id is required"))
+	}
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversation name is required"))
+	}
+
+	template, existed, err := workflow.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if existed {
+		cID, _, existed, err := workflow.GetRepository().GetOrCreateStaticConversation(ctx, env, conversationIDGenerator, &vo.CreateStaticConversation{
+			AppID:       ptr.From(appID),
+			TemplateID:  template.TemplateID,
+			UserID:      userID,
+			ConnectorID: connectorID,
+		})
+		if err != nil {
+			return nil, err
+		}
+		return map[string]any{
+			"isSuccess":      true,
+			"conversationId": cID,
+			"isExisted":      existed,
+		}, nil
+	}
+
+	cID, _, existed, err := workflow.GetRepository().GetOrCreateDynamicConversation(ctx, env, conversationIDGenerator, &vo.CreateDynamicConversation{
+		AppID:       ptr.From(appID),
+		UserID:      userID,
+		ConnectorID: connectorID,
+		Name:        conversationName,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return map[string]any{
+		"isSuccess":      true,
+		"conversationId": cID,
+		"isExisted":      existed,
+	}, nil
+
+}

backend/domain/workflow/internal/nodes/conversation/createmessage.go

@@ -0,0 +1,299 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/coze-dev/coze-studio/backend/api/model/conversation/common"
+	conventity "github.com/coze-dev/coze-studio/backend/domain/conversation/conversation/entity"
+
+	"strconv"
+	"sync/atomic"
+
+	einoSchema "github.com/cloudwego/eino/schema"
+	model "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/message"
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossagentrun "github.com/coze-dev/coze-studio/backend/crossdomain/contract/agentrun"
+	crossconversation "github.com/coze-dev/coze-studio/backend/crossdomain/contract/conversation"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+
+	agententity "github.com/coze-dev/coze-studio/backend/domain/conversation/agentrun/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type CreateMessageConfig struct{}
+
+type CreateMessage struct{}
+
+func (c *CreateMessageConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeCreateMessage,
+		Name:    n.Data.Meta.Title,
+		Configs: c,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (c *CreateMessageConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &CreateMessage{}, nil
+}
+
+func (c *CreateMessage) getConversationIDByName(ctx context.Context, env vo.Env, appID *int64, version, conversationName string, userID, connectorID int64) (int64, error) {
+	template, isExist, err := workflow.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	conversationIDGenerator := workflow.ConversationIDGenerator(func(ctx context.Context, appID int64, userID, connectorID int64) (*conventity.Conversation, error) {
+		return crossconversation.DefaultSVC().CreateConversation(ctx, &conventity.CreateMeta{
+			AgentID:     appID,
+			UserID:      userID,
+			ConnectorID: connectorID,
+			Scene:       common.Scene_SceneWorkflow,
+		})
+	})
+
+	var conversationID int64
+	if isExist {
+		cID, _, _, err := workflow.GetRepository().GetOrCreateStaticConversation(ctx, env, conversationIDGenerator, &vo.CreateStaticConversation{
+			AppID:       ptr.From(appID),
+			TemplateID:  template.TemplateID,
+			UserID:      userID,
+			ConnectorID: connectorID,
+		})
+		if err != nil {
+			return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		conversationID = cID
+	} else {
+		dc, _, err := workflow.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if dc != nil {
+			conversationID = dc.ConversationID
+		}
+	}
+	return conversationID, nil
+}
+
+func (c *CreateMessage) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+	)
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversationName is required"))
+	}
+
+	role, ok := input["role"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("role is required"))
+	}
+	if role != "user" && role != "assistant" {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, fmt.Errorf("role must be user or assistant"))
+	}
+
+	content, ok := input["content"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("content is required"))
+	}
+
+	var conversationID int64
+	var err error
+	var resolvedAppID int64
+	if appID == nil {
+		if conversationName != "Default" {
+			return nil, vo.WrapError(errno.ErrOnlyDefaultConversationAllowInAgentScenario, errors.New("conversation node only allow in application"))
+		}
+		if agentID == nil || execCtx.ExeCfg.ConversationID == nil {
+			return map[string]any{
+				"isSuccess": false,
+				"message": map[string]any{
+					"messageId":   "0",
+					"role":        role,
+					"contentType": "text",
+					"content":     content,
+				},
+			}, nil
+		}
+		conversationID = *execCtx.ExeCfg.ConversationID
+		resolvedAppID = *agentID
+	} else {
+		conversationID, err = c.getConversationIDByName(ctx, env, appID, version, conversationName, userID, connectorID)
+		if err != nil {
+			return nil, err
+		}
+		resolvedAppID = *appID
+	}
+
+	if conversationID == 0 {
+		return map[string]any{
+			"isSuccess": false,
+			"message": map[string]any{
+				"messageId":   "0",
+				"role":        role,
+				"contentType": "text",
+				"content":     content,
+			},
+		}, nil
+	}
+
+	currentConversationID := execCtx.ExeCfg.ConversationID
+	isCurrentConversation := currentConversationID != nil && *currentConversationID == conversationID
+	var runID int64
+	var sectionID int64
+	if isCurrentConversation {
+		if execCtx.ExeCfg.SectionID != nil {
+			sectionID = *execCtx.ExeCfg.SectionID
+		} else {
+			return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("section id is required"))
+		}
+	} else {
+		cInfo, err := crossconversation.DefaultSVC().GetByID(ctx, conversationID)
+		if err != nil {
+			return nil, err
+		}
+		sectionID = cInfo.SectionID
+	}
+
+	if role == "user" {
+		// For user messages, always create a new run and store the ID in the context.
+		runRecord, err := crossagentrun.DefaultSVC().Create(ctx, &agententity.AgentRunMeta{
+			AgentID:        resolvedAppID,
+			ConversationID: conversationID,
+			UserID:         strconv.FormatInt(userID, 10),
+			ConnectorID:    connectorID,
+			SectionID:      sectionID,
+		})
+		if err != nil {
+			return nil, err
+		}
+		newRunID := runRecord.ID
+		if execCtx.ExeCfg.RoundID != nil {
+			atomic.StoreInt64(execCtx.ExeCfg.RoundID, newRunID)
+		}
+		runID = newRunID
+	} else if isCurrentConversation {
+		// For assistant messages in the same conversation, reuse the runID from the context.
+		if execCtx.ExeCfg.RoundID == nil {
+			// This indicates an inconsistent state, as a user message should have set this.
+			return map[string]any{
+				"isSuccess": false,
+				"message": map[string]any{
+					"messageId":   "0",
+					"role":        role,
+					"contentType": "text",
+					"content":     content,
+				},
+			}, nil
+		}
+		runID = *execCtx.ExeCfg.RoundID
+	} else {
+		// For assistant messages in a different conversation or a new workflow run,
+		// find the latest runID or create a new one as a fallback.
+		runIDs, err := crossmessage.DefaultSVC().GetLatestRunIDs(ctx, &crossmessage.GetLatestRunIDsRequest{
+			ConversationID: conversationID,
+			UserID:         userID,
+			AppID:          resolvedAppID,
+			Rounds:         1,
+		})
+		if err != nil {
+			return nil, err
+		}
+		if len(runIDs) > 0 && runIDs[0] != 0 {
+			runID = runIDs[0]
+		} else {
+			runRecord, err := crossagentrun.DefaultSVC().Create(ctx, &agententity.AgentRunMeta{
+				AgentID:        resolvedAppID,
+				ConversationID: conversationID,
+				UserID:         strconv.FormatInt(userID, 10),
+				ConnectorID:    connectorID,
+				SectionID:      sectionID,
+			})
+			if err != nil {
+				return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+			}
+			runID = runRecord.ID
+		}
+	}
+
+	message := &model.Message{
+		ConversationID: conversationID,
+		Role:           einoSchema.RoleType(role),
+		Content:        content,
+		ContentType:    model.ContentType("text"),
+		UserID:         strconv.FormatInt(userID, 10),
+		AgentID:        resolvedAppID,
+		RunID:          runID,
+		SectionID:      sectionID,
+	}
+	if message.Role == einoSchema.User {
+		message.MessageType = model.MessageTypeQuestion
+	} else {
+		message.MessageType = model.MessageTypeAnswer
+	}
+	msg, err := crossmessage.DefaultSVC().Create(ctx, message)
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	messageOutput := map[string]any{
+		"messageId":   msg.ID,
+		"role":        role,
+		"contentType": "text",
+		"content":     content,
+	}
+
+	return map[string]any{
+		"isSuccess": true,
+		"message":   messageOutput,
+	}, nil
+}

backend/domain/workflow/internal/nodes/conversation/deleteconversation.go

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type DeleteConversationConfig struct{}
+
+type DeleteConversation struct{}
+
+func (d *DeleteConversationConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeConversationDelete,
+		Name:    n.Data.Meta.Title,
+		Configs: d,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (d *DeleteConversationConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &DeleteConversation{}, nil
+}
+
+func (d *DeleteConversation) Invoke(ctx context.Context, in map[string]any) (map[string]any, error) {
+
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+	)
+
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, delete conversation is not available"))
+	}
+
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, errors.New("delete conversation node, app id is required"))
+	}
+
+	cName, ok := in["conversationName"]
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversation name is required"))
+	}
+
+	conversationName := cName.(string)
+
+	_, existed, err := workflow.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if existed {
+		return nil, vo.WrapError(errno.ErrConversationNodeInvalidOperation, fmt.Errorf("only conversation created through nodes are allowed to be modified or deleted"))
+	}
+
+	dyConversation, existed, err := workflow.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+	if err != nil {
+		return nil, err
+	}
+
+	if !existed {
+		return nil, vo.WrapError(errno.ErrConversationOfAppNotFound, fmt.Errorf("the conversation name does not exist: '%v'", conversationName))
+	}
+
+	_, err = workflow.GetRepository().DeleteDynamicConversation(ctx, env, dyConversation.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return map[string]any{
+		"isSuccess": true,
+	}, nil
+}

backend/domain/workflow/internal/nodes/conversation/deletemessage.go

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+	msgentity "github.com/coze-dev/coze-studio/backend/domain/conversation/message/entity"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+
+	wf "github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type DeleteMessageConfig struct{}
+
+type DeleteMessage struct{}
+
+func (d *DeleteMessageConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeDeleteMessage,
+		Name:    n.Data.Meta.Title,
+		Configs: d,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (d *DeleteMessageConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &DeleteMessage{}, nil
+}
+
+func (d *DeleteMessage) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+
+		successMap = map[string]any{
+			"isSuccess": true,
+		}
+		failedMap = map[string]any{
+			"isSuccess": false,
+		}
+	)
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversationName is required"))
+	}
+	messageStr, ok := input["messageId"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("messageId is required"))
+	}
+	messageID, err := strconv.ParseInt(messageStr, 10, 64)
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, err)
+	}
+
+	if appID == nil {
+		if conversationName != "Default" {
+			return nil, vo.WrapError(errno.ErrOnlyDefaultConversationAllowInAgentScenario, fmt.Errorf("only default conversation allow in agent scenario"))
+		}
+
+		if agentID == nil || execCtx.ExeCfg.ConversationID == nil {
+			return failedMap, nil
+		}
+
+		err = crossmessage.DefaultSVC().Delete(ctx, &msgentity.DeleteMeta{MessageIDs: []int64{messageID}, ConversationID: execCtx.ExeCfg.ConversationID})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		return successMap, nil
+	}
+
+	t, existed, err := wf.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	if existed {
+		sc, existed, err := wf.GetRepository().GetStaticConversationByTemplateID(ctx, env, userID, connectorID, t.TemplateID)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		if !existed {
+			return failedMap, nil
+		}
+
+		err = crossmessage.DefaultSVC().Delete(ctx, &msgentity.DeleteMeta{MessageIDs: []int64{messageID}, ConversationID: ptr.Of(sc.ConversationID)})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		return successMap, nil
+
+	} else {
+		dc, existed, err := wf.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		if !existed {
+			return failedMap, nil
+		}
+
+		err = crossmessage.DefaultSVC().Delete(ctx, &msgentity.DeleteMeta{MessageIDs: []int64{messageID}, ConversationID: ptr.Of(dc.ConversationID)})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		return successMap, nil
+
+	}
+
+}

backend/domain/workflow/internal/nodes/conversation/editmessage.go

@@ -0,0 +1,181 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	model "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/message"
+	"strconv"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	"github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type EditMessageConfig struct{}
+
+type EditMessage struct{}
+
+func (e *EditMessageConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeEditMessage,
+		Name:    n.Data.Meta.Title,
+		Configs: e,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (e *EditMessageConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &EditMessage{}, nil
+}
+
+func (e *EditMessage) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+
+		successMap = map[string]any{
+			"isSuccess": true,
+		}
+		failedMap = map[string]any{
+			"isSuccess": false,
+		}
+	)
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversationName is required"))
+	}
+
+	messageStr, ok := input["messageId"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("messageId is required"))
+	}
+
+	messageID, err := strconv.ParseInt(messageStr, 10, 64)
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	newContent, ok := input["newContent"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("newContent is required"))
+	}
+
+	if appID == nil {
+		if conversationName != "Default" {
+			return nil, vo.WrapError(errno.ErrOnlyDefaultConversationAllowInAgentScenario, fmt.Errorf("only default conversation allow in agent scenario"))
+		}
+
+		if agentID == nil || execCtx.ExeCfg.ConversationID == nil {
+			return failedMap, nil
+		}
+
+		_, err = crossmessage.DefaultSVC().Edit(ctx, &model.Message{ConversationID: *execCtx.ExeCfg.ConversationID, ID: messageID, Content: newContent})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		return successMap, err
+	}
+
+	msg, err := message.DefaultSVC().GetMessageByID(ctx, messageID)
+	if err != nil {
+		return nil, err
+	}
+
+	if msg == nil {
+		return nil, vo.NewError(errno.ErrMessageNodeOperationFail, errorx.KV("cause", "message not found"))
+	}
+
+	if msg.Content == newContent {
+		return successMap, nil
+	}
+
+	t, existed, err := workflow.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	if existed {
+		sts, existed, err := workflow.GetRepository().GetStaticConversationByTemplateID(ctx, env, userID, connectorID, t.TemplateID)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		if !existed {
+			return failedMap, nil
+		}
+
+		_, err = crossmessage.DefaultSVC().Edit(ctx, &model.Message{ConversationID: sts.ConversationID, ID: messageID, Content: newContent})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		return successMap, nil
+
+	} else {
+		dyConversation, existed, err := workflow.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		if !existed {
+			return failedMap, nil
+		}
+
+		_, err = crossmessage.DefaultSVC().Edit(ctx, &model.Message{ConversationID: dyConversation.ConversationID, ID: messageID, Content: newContent})
+		if err != nil {
+			return nil, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+
+		return successMap, nil
+
+	}
+
+}

backend/domain/workflow/internal/nodes/conversation/messagelist.go

@@ -0,0 +1,207 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type MessageListConfig struct{}
+
+type MessageList struct{}
+
+func (m *MessageListConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeMessageList,
+		Name:    n.Data.Meta.Title,
+		Configs: m,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (m *MessageListConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &MessageList{}, nil
+}
+
+func (m *MessageList) getConversationIDByName(ctx context.Context, env vo.Env, appID *int64, version, conversationName string, userID, connectorID int64) (int64, error) {
+	template, isExist, err := workflow.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+
+	if err != nil {
+		return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+	}
+
+	var conversationID int64
+	if isExist {
+		sc, _, err := workflow.GetRepository().GetStaticConversationByTemplateID(ctx, env, userID, connectorID, template.TemplateID)
+		if err != nil {
+			return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if sc != nil {
+			conversationID = sc.ConversationID
+		}
+	} else {
+		dc, _, err := workflow.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+		if err != nil {
+			return 0, vo.WrapError(errno.ErrMessageNodeOperationFail, err, errorx.KV("cause", vo.UnwrapRootErr(err).Error()))
+		}
+		if dc != nil {
+			conversationID = dc.ConversationID
+		}
+	}
+
+	return conversationID, nil
+}
+
+func (m *MessageList) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+	)
+
+	conversationName, ok := input["conversationName"].(string)
+	if !ok {
+		return nil, vo.WrapError(errno.ErrConversationNodeInvalidOperation, errors.New("ConversationName is required"))
+	}
+
+	var conversationID int64
+	var err error
+	var resolvedAppID int64
+	if appID == nil {
+		if conversationName != "Default" {
+			return nil, vo.WrapError(errno.ErrOnlyDefaultConversationAllowInAgentScenario, errors.New("conversation node only allow in application"))
+		}
+		if agentID == nil || execCtx.ExeCfg.ConversationID == nil {
+			return map[string]any{
+				"messageList": []any{},
+				"firstId":     "0",
+				"lastId":      "0",
+				"hasMore":     false,
+			}, nil
+		}
+		conversationID = *execCtx.ExeCfg.ConversationID
+		resolvedAppID = *agentID
+	} else {
+		conversationID, err = m.getConversationIDByName(ctx, env, appID, version, conversationName, userID, connectorID)
+		if err != nil {
+			return nil, err
+		}
+		resolvedAppID = *appID
+	}
+
+	req := &crossmessage.MessageListRequest{
+		UserID:         userID,
+		AppID:          resolvedAppID,
+		ConversationID: conversationID,
+	}
+
+	if req.ConversationID == 0 {
+		return map[string]any{
+			"messageList": []any{},
+			"firstId":     "0",
+			"lastId":      "0",
+			"hasMore":     false,
+		}, nil
+	}
+
+	limit, ok := input["limit"].(int64)
+	if ok {
+		if limit > 0 && limit <= 50 {
+			req.Limit = limit
+		} else {
+			req.Limit = 50
+		}
+	} else {
+		req.Limit = 50
+	}
+	beforeID, ok := input["beforeId"].(string)
+	if ok {
+
+		req.BeforeID = &beforeID
+	}
+	afterID, ok := input["afterId"].(string)
+	if ok {
+
+		req.AfterID = &afterID
+	}
+
+	if beforeID != "" && afterID != "" {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, fmt.Errorf("BeforeID and AfterID cannot be set at the same time"))
+	}
+
+	ml, err := crossmessage.DefaultSVC().MessageList(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var messageList []any
+	for _, msg := range ml.Messages {
+		content, err := nodes.ConvertMessageToString(ctx, msg)
+		if err != nil {
+			return nil, err
+		}
+		messageList = append(messageList, map[string]any{
+			"messageId":   strconv.FormatInt(msg.ID, 10),
+			"role":        string(msg.Role),
+			"contentType": msg.ContentType,
+			"content":     content,
+		})
+	}
+
+	return map[string]any{
+		"messageList": messageList,
+		"firstId":     ml.FirstID,
+		"lastId":      ml.LastID,
+		"hasMore":     ml.HasMore,
+	}, nil
+
+}

backend/domain/workflow/internal/nodes/conversation/updateconversation.go

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+
+	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
+
+	wf "github.com/coze-dev/coze-studio/backend/domain/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/types/errno"
+)
+
+type UpdateConversationConfig struct{}
+
+type UpdateConversation struct{}
+
+func (c *UpdateConversationConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
+	ns := &schema.NodeSchema{
+		Key:     vo.NodeKey(n.ID),
+		Type:    entity.NodeTypeConversationUpdate,
+		Name:    n.Data.Meta.Title,
+		Configs: c,
+	}
+
+	if err := convert.SetInputsForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	if err := convert.SetOutputTypesForNodeSchema(n, ns); err != nil {
+		return nil, err
+	}
+
+	return ns, nil
+}
+
+func (c *UpdateConversationConfig) Build(_ context.Context, ns *schema.NodeSchema, _ ...schema.BuildOption) (any, error) {
+	return &UpdateConversation{}, nil
+}
+
+func (c *UpdateConversation) Invoke(ctx context.Context, in map[string]any) (map[string]any, error) {
+
+	var (
+		execCtx     = execute.GetExeCtx(ctx)
+		env         = ternary.IFElse(execCtx.ExeCfg.Mode == workflowModel.ExecuteModeRelease, vo.Online, vo.Draft)
+		appID       = execCtx.ExeCfg.AppID
+		agentID     = execCtx.ExeCfg.AgentID
+		version     = execCtx.ExeCfg.Version
+		connectorID = execCtx.ExeCfg.ConnectorID
+		userID      = execCtx.ExeCfg.Operator
+	)
+	cName, ok := in["conversationName"]
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("conversation name is required"))
+	}
+
+	conversationName := cName.(string)
+
+	ncName, ok := in["newConversationName"]
+	if !ok {
+		return nil, vo.WrapError(errno.ErrInvalidParameter, errors.New("new conversationName name is required"))
+	}
+
+	newConversationName := ncName.(string)
+
+	if agentID != nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, fmt.Errorf("in the agent scenario, update conversation is not available"))
+	}
+
+	if appID == nil {
+		return nil, vo.WrapError(errno.ErrConversationNodesNotAvailable, errors.New("conversation update node, app id is required"))
+	}
+
+	_, existed, err := wf.GetRepository().GetConversationTemplate(ctx, env, vo.GetConversationTemplatePolicy{
+		AppID:   appID,
+		Name:    ptr.Of(conversationName),
+		Version: ptr.Of(version),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if existed {
+		return nil, vo.WrapError(errno.ErrConversationNodeInvalidOperation, fmt.Errorf("only conversation created through nodes are allowed to be modified or deleted"))
+	}
+
+	conversation, existed, err := wf.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, conversationName)
+	if err != nil {
+		return nil, err
+	}
+
+	if !existed {
+		return map[string]any{
+			"conversationId": "0",
+			"isSuccess":      false,
+			"isExisted":      false,
+		}, nil
+	}
+
+	ncConversation, existed, err := wf.GetRepository().GetDynamicConversationByName(ctx, env, *appID, connectorID, userID, newConversationName)
+	if err != nil {
+		return nil, err
+	}
+
+	if existed {
+		return map[string]any{
+			"conversationId": strconv.FormatInt(ncConversation.ConversationID, 10),
+			"isSuccess":      false,
+			"isExisted":      true,
+		}, nil
+	}
+
+	err = wf.GetRepository().UpdateDynamicConversationNameByID(ctx, env, conversation.ID, newConversationName)
+	if err != nil {
+		return nil, err
+	}
+
+	return map[string]any{
+		"conversationId": strconv.FormatInt(conversation.ConversationID, 10),
+		"isSuccess":      true,
+		"isExisted":      false,
+	}, nil
+
+}

backend/domain/workflow/internal/nodes/intentdetector/intent_detector.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"maps"
 	"strconv"
 	"strings"
 
@@ -29,21 +30,26 @@ import (
 	"github.com/spf13/cast"
 
 	model "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/modelmgr"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
 	crossmodelmgr "github.com/coze-dev/coze-studio/backend/crossdomain/contract/modelmgr"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
 	schema2 "github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/ctxcache"
 	"github.com/coze-dev/coze-studio/backend/pkg/lang/ternary"
+	"github.com/coze-dev/coze-studio/backend/pkg/logs"
 	"github.com/coze-dev/coze-studio/backend/pkg/sonic"
 )
 
 type Config struct {
-	Intents      []string
-	SystemPrompt string
-	IsFastMode   bool
-	LLMParams    *model.LLMParams
+	Intents            []string
+	SystemPrompt       string
+	IsFastMode         bool
+	LLMParams          *model.LLMParams
+	ChatHistorySetting *vo.ChatHistorySetting
 }
 
 func (c *Config) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema2.NodeSchema, error) {
@@ -59,6 +65,10 @@ func (c *Config) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*
 		return nil, fmt.Errorf("intent detector node's llmParam is nil")
 	}
 
+	if n.Data.Inputs.ChatHistorySetting != nil {
+		c.ChatHistorySetting = n.Data.Inputs.ChatHistorySetting
+	}
+
 	llmParam, ok := param.(vo.IntentDetectorLLMParam)
 	if !ok {
 		return nil, fmt.Errorf("llm node's llmParam must be LLMParam, got %v", llmParam)
@@ -141,14 +151,16 @@ func (c *Config) Build(ctx context.Context, _ *schema2.NodeSchema, _ ...schema2.
 		&schema.Message{Content: sptTemplate, Role: schema.System},
 		&schema.Message{Content: "{{query}}", Role: schema.User})
 
-	r, err := chain.AppendChatTemplate(prompts).AppendChatModel(m).Compile(ctx)
+	r, err := chain.AppendChatTemplate(newHistoryChatTemplate(prompts, c.ChatHistorySetting)).AppendChatModel(m).Compile(ctx)
 	if err != nil {
 		return nil, err
 	}
+
 	return &IntentDetector{
-		isFastMode:   c.IsFastMode,
-		systemPrompt: c.SystemPrompt,
-		runner:       r,
+		isFastMode:         c.IsFastMode,
+		systemPrompt:       c.SystemPrompt,
+		runner:             r,
+		ChatHistorySetting: c.ChatHistorySetting,
 	}, nil
 }
 
@@ -182,6 +194,10 @@ func (c *Config) ExpectPorts(ctx context.Context, n *vo.Node) []string {
 	return expects
 }
 
+type contextKey string
+
+const chatHistoryKey contextKey = "chatHistory"
+
 const SystemIntentPrompt = `
 # Role
 You are an intention classification expert, good at being able to judge which classification the user's input belongs to.
@@ -240,9 +256,10 @@ Note:
 const classificationID = "classificationId"
 
 type IntentDetector struct {
-	isFastMode   bool
-	systemPrompt string
-	runner       compose.Runnable[map[string]any, *schema.Message]
+	isFastMode         bool
+	systemPrompt       string
+	runner             compose.Runnable[map[string]any, *schema.Message]
+	ChatHistorySetting *vo.ChatHistorySetting
 }
 
 func (id *IntentDetector) parseToNodeOut(content string) (map[string]any, error) {
@@ -320,3 +337,66 @@ func toIntentString(its []string) (string, error) {
 
 	return sonic.MarshalString(vs)
 }
+
+func (id *IntentDetector) ToCallbackInput(ctx context.Context, in map[string]any) (map[string]any, error) {
+	if id.ChatHistorySetting == nil || !id.ChatHistorySetting.EnableChatHistory {
+		return in, nil
+	}
+
+	var messages []*crossmessage.WfMessage
+	var scMessages []*schema.Message
+	var sectionID *int64
+	execCtx := execute.GetExeCtx(ctx)
+	if execCtx != nil {
+		messages = execCtx.ExeCfg.ConversationHistory
+		scMessages = execCtx.ExeCfg.ConversationHistorySchemaMessages
+		sectionID = execCtx.ExeCfg.SectionID
+	}
+
+	ret := map[string]any{
+		"chatHistory": []any{},
+	}
+	maps.Copy(ret, in)
+
+	if len(messages) == 0 {
+		return ret, nil
+	}
+	if sectionID != nil && messages[0].SectionID != *sectionID {
+		return ret, nil
+	}
+
+	maxRounds := int(id.ChatHistorySetting.ChatHistoryRound)
+	if execCtx != nil && execCtx.ExeCfg.MaxHistoryRounds != nil {
+		maxRounds = min(int(*execCtx.ExeCfg.MaxHistoryRounds), maxRounds)
+	}
+
+	count := 0
+	startIdx := 0
+	for i := len(messages) - 1; i >= 0; i-- {
+		if messages[i].Role == schema.User {
+			count++
+		}
+		if count >= maxRounds {
+			startIdx = i
+			break
+		}
+	}
+
+	var historyMessages []any
+	for _, msg := range messages[startIdx:] {
+		content, err := nodes.ConvertMessageToString(ctx, msg)
+		if err != nil {
+			logs.CtxWarnf(ctx, "failed to convert message to string: %v", err)
+			continue
+		}
+		historyMessages = append(historyMessages, map[string]any{
+			"role":    string(msg.Role),
+			"content": content,
+		})
+	}
+
+	ctxcache.Store(ctx, chatHistoryKey, scMessages[startIdx:])
+
+	ret["chatHistory"] = historyMessages
+	return ret, nil
+}

backend/domain/workflow/internal/nodes/intentdetector/prompt.go

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package intentdetector
+
+import (
+	"context"
+	"fmt"
+	"github.com/cloudwego/eino/components/prompt"
+	"github.com/cloudwego/eino/schema"
+
+	"github.com/coze-dev/coze-studio/backend/api/model/workflow"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
+	"github.com/coze-dev/coze-studio/backend/pkg/ctxcache"
+	"github.com/coze-dev/coze-studio/backend/pkg/logs"
+)
+
+type historyChatTemplate struct {
+	basePrompt         prompt.ChatTemplate
+	chatHistorySetting *vo.ChatHistorySetting
+}
+
+func newHistoryChatTemplate(basePrompt prompt.ChatTemplate, chatHistorySetting *vo.ChatHistorySetting) prompt.ChatTemplate {
+	return &historyChatTemplate{
+		basePrompt:         basePrompt,
+		chatHistorySetting: chatHistorySetting,
+	}
+}
+
+func (t *historyChatTemplate) Format(ctx context.Context, vs map[string]any, opts ...prompt.Option) ([]*schema.Message, error) {
+	baseMessages, err := t.basePrompt.Format(ctx, vs, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to format base prompt: %w", err)
+	}
+	if len(baseMessages) == 0 {
+		return nil, fmt.Errorf("base prompt returned no messages")
+	}
+
+	if t.chatHistorySetting == nil || !t.chatHistorySetting.EnableChatHistory {
+		return baseMessages, nil
+	}
+
+	exeCtx := execute.GetExeCtx(ctx)
+	if exeCtx == nil {
+		logs.CtxWarnf(ctx, "execute context is nil, skipping chat history")
+		return baseMessages, nil
+	}
+
+	if exeCtx.ExeCfg.WorkflowMode != workflow.WorkflowMode_ChatFlow {
+		return baseMessages, nil
+	}
+
+	historyMessages, ok := ctxcache.Get[[]*schema.Message](ctx, chatHistoryKey)
+	if !ok || len(historyMessages) == 0 {
+		logs.CtxWarnf(ctx, "conversation history is empty")
+		return baseMessages, nil
+	}
+
+	if len(historyMessages) == 0 {
+		return baseMessages, nil
+	}
+
+	finalMessages := make([]*schema.Message, 0, len(baseMessages)+len(historyMessages))
+	finalMessages = append(finalMessages, baseMessages[0]) // System prompt
+	finalMessages = append(finalMessages, historyMessages...)
+	if len(baseMessages) > 1 {
+		finalMessages = append(finalMessages, baseMessages[1:]...) // User prompt and any others
+	}
+
+	return finalMessages, nil
+}

backend/domain/workflow/internal/nodes/knowledge/knowledge_retrieve.go

@@ -19,24 +19,37 @@ package knowledge
 import (
 	"context"
 	"errors"
+	"maps"
 
 	"github.com/spf13/cast"
 
+	einoSchema "github.com/cloudwego/eino/schema"
+
 	"github.com/coze-dev/coze-studio/backend/api/model/crossdomain/knowledge"
+	"github.com/coze-dev/coze-studio/backend/api/model/workflow"
 	crossknowledge "github.com/coze-dev/coze-studio/backend/crossdomain/contract/knowledge"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/canvas/convert"
+	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
+	"github.com/coze-dev/coze-studio/backend/pkg/ctxcache"
 	"github.com/coze-dev/coze-studio/backend/pkg/lang/slices"
+	"github.com/coze-dev/coze-studio/backend/pkg/logs"
 )
 
 const outputList = "outputList"
 
+type contextKey string
+
+const chatHistoryKey contextKey = "chatHistory"
+
 type RetrieveConfig struct {
-	KnowledgeIDs      []int64
-	RetrievalStrategy *knowledge.RetrievalStrategy
+	KnowledgeIDs       []int64
+	RetrievalStrategy  *knowledge.RetrievalStrategy
+	ChatHistorySetting *vo.ChatHistorySetting
 }
 
 func (r *RetrieveConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema.NodeSchema, error) {
@@ -60,6 +73,10 @@ func (r *RetrieveConfig) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOp
 	}
 	r.KnowledgeIDs = knowledgeIDs
 
+	if inputs.ChatHistorySetting != nil {
+		r.ChatHistorySetting = inputs.ChatHistorySetting
+	}
+
 	retrievalStrategy := &knowledge.RetrievalStrategy{}
 
 	var getDesignatedParamContent = func(name string) (any, bool) {
@@ -154,14 +171,16 @@ func (r *RetrieveConfig) Build(_ context.Context, _ *schema.NodeSchema, _ ...sch
 	}
 
 	return &Retrieve{
-		knowledgeIDs:      r.KnowledgeIDs,
-		retrievalStrategy: r.RetrievalStrategy,
+		knowledgeIDs:       r.KnowledgeIDs,
+		retrievalStrategy:  r.RetrievalStrategy,
+		ChatHistorySetting: r.ChatHistorySetting,
 	}, nil
 }
 
 type Retrieve struct {
-	knowledgeIDs      []int64
-	retrievalStrategy *knowledge.RetrievalStrategy
+	knowledgeIDs       []int64
+	retrievalStrategy  *knowledge.RetrievalStrategy
+	ChatHistorySetting *vo.ChatHistorySetting
 }
 
 func (kr *Retrieve) Invoke(ctx context.Context, input map[string]any) (map[string]any, error) {
@@ -173,6 +192,7 @@ func (kr *Retrieve) Invoke(ctx context.Context, input map[string]any) (map[strin
 	req := &knowledge.RetrieveRequest{
 		Query:        query,
 		KnowledgeIDs: kr.knowledgeIDs,
+		ChatHistory:  kr.GetChatHistoryOrNil(ctx, kr.ChatHistorySetting),
 		Strategy:     kr.retrievalStrategy,
 	}
 
@@ -190,3 +210,89 @@ func (kr *Retrieve) Invoke(ctx context.Context, input map[string]any) (map[strin
 
 	return result, nil
 }
+
+func (kr *Retrieve) GetChatHistoryOrNil(ctx context.Context, ChatHistorySetting *vo.ChatHistorySetting) []*einoSchema.Message {
+	if ChatHistorySetting == nil || !ChatHistorySetting.EnableChatHistory {
+		return nil
+	}
+
+	exeCtx := execute.GetExeCtx(ctx)
+	if exeCtx == nil {
+		logs.CtxWarnf(ctx, "execute context is nil, skipping chat history")
+		return nil
+	}
+	if exeCtx.ExeCfg.WorkflowMode != workflow.WorkflowMode_ChatFlow {
+		return nil
+	}
+
+	historyMessages, ok := ctxcache.Get[[]*einoSchema.Message](ctx, chatHistoryKey)
+
+	if !ok || len(historyMessages) == 0 {
+		logs.CtxWarnf(ctx, "conversation history is empty")
+		return nil
+	}
+	return historyMessages
+}
+
+func (kr *Retrieve) ToCallbackInput(ctx context.Context, in map[string]any) (map[string]any, error) {
+	if kr.ChatHistorySetting == nil || !kr.ChatHistorySetting.EnableChatHistory {
+		return in, nil
+	}
+
+	var messages []*crossmessage.WfMessage
+	var scMessages []*einoSchema.Message
+	var sectionID *int64
+	execCtx := execute.GetExeCtx(ctx)
+	if execCtx != nil {
+		messages = execCtx.ExeCfg.ConversationHistory
+		scMessages = execCtx.ExeCfg.ConversationHistorySchemaMessages
+		sectionID = execCtx.ExeCfg.SectionID
+	}
+
+	ret := map[string]any{
+		"chatHistory": []any{},
+	}
+	maps.Copy(ret, in)
+
+	if len(messages) == 0 {
+		return ret, nil
+	}
+
+	if sectionID != nil && messages[0].SectionID != *sectionID {
+		return ret, nil
+	}
+
+	maxRounds := int(kr.ChatHistorySetting.ChatHistoryRound)
+	if execCtx != nil && execCtx.ExeCfg.MaxHistoryRounds != nil {
+		maxRounds = min(int(*execCtx.ExeCfg.MaxHistoryRounds), maxRounds)
+	}
+
+	count := 0
+	startIdx := 0
+	for i := len(messages) - 1; i >= 0; i-- {
+		if messages[i].Role == einoSchema.User {
+			count++
+		}
+		if count >= maxRounds {
+			startIdx = i
+			break
+		}
+	}
+
+	var historyMessages []any
+	for _, msg := range messages[startIdx:] {
+		content, err := nodes.ConvertMessageToString(ctx, msg)
+		if err != nil {
+			logs.CtxWarnf(ctx, "failed to convert message to string: %v", err)
+			continue
+		}
+		historyMessages = append(historyMessages, map[string]any{
+			"role":    string(msg.Role),
+			"content": content,
+		})
+	}
+	ctxcache.Store(ctx, chatHistoryKey, scMessages[startIdx:])
+
+	ret["chatHistory"] = historyMessages
+	return ret, nil
+}

backend/domain/workflow/internal/nodes/llm/llm.go

@@ -40,6 +40,7 @@ import (
 	workflowModel "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
 	workflow3 "github.com/coze-dev/coze-studio/backend/api/model/workflow"
 	crossknowledge "github.com/coze-dev/coze-studio/backend/crossdomain/contract/knowledge"
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
 	crossmodelmgr "github.com/coze-dev/coze-studio/backend/crossdomain/contract/modelmgr"
 	crossplugin "github.com/coze-dev/coze-studio/backend/crossdomain/contract/plugin"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow"
@@ -59,6 +60,10 @@ import (
 	"github.com/coze-dev/coze-studio/backend/types/errno"
 )
 
+type contextKey string
+
+const chatHistoryKey contextKey = "chatHistory"
+
 type Format int
 
 const (
@@ -167,12 +172,14 @@ type KnowledgeRecallConfig struct {
 }
 
 type Config struct {
-	SystemPrompt    string
-	UserPrompt      string
-	OutputFormat    Format
-	LLMParams       *crossmodel.LLMParams
-	FCParam         *vo.FCParam
-	BackupLLMParams *crossmodel.LLMParams
+	SystemPrompt                      string
+	UserPrompt                        string
+	OutputFormat                      Format
+	LLMParams                         *crossmodel.LLMParams
+	FCParam                           *vo.FCParam
+	BackupLLMParams                   *crossmodel.LLMParams
+	ChatHistorySetting                *vo.ChatHistorySetting
+	AssociateStartNodeUserInputFields map[string]struct{}
 }
 
 func (c *Config) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*schema2.NodeSchema, error) {
@@ -202,6 +209,13 @@ func (c *Config) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*
 	c.SystemPrompt = convertedLLMParam.SystemPrompt
 	c.UserPrompt = convertedLLMParam.Prompt
 
+	if convertedLLMParam.EnableChatHistory {
+		c.ChatHistorySetting = &vo.ChatHistorySetting{
+			EnableChatHistory: true,
+			ChatHistoryRound:  convertedLLMParam.ChatHistoryRound,
+		}
+	}
+
 	var resFormat Format
 	switch convertedLLMParam.ResponseFormat {
 	case crossmodel.ResponseFormatText:
@@ -273,6 +287,15 @@ func (c *Config) Adapt(_ context.Context, n *vo.Node, _ ...nodes.AdaptOption) (*
 		}
 	}
 
+	c.AssociateStartNodeUserInputFields = make(map[string]struct{})
+	for _, info := range ns.InputSources {
+		if len(info.Path) == 1 && info.Source.Ref != nil && info.Source.Ref.FromNodeKey == entity.EntryNodeKey {
+			if compose.FromFieldPath(info.Source.Ref.FromPath).Equals(compose.FromField("USER_INPUT")) {
+				c.AssociateStartNodeUserInputFields[info.Path[0]] = struct{}{}
+			}
+		}
+	}
+
 	return ns, nil
 }
 
@@ -320,7 +343,14 @@ func llmParamsToLLMParam(params vo.LLMParam) (*crossmodel.LLMParams, error) {
 		case "systemPrompt":
 			strVal := param.Input.Value.Content.(string)
 			p.SystemPrompt = strVal
-		case "chatHistoryRound", "generationDiversity", "frequencyPenalty", "presencePenalty":
+		case "chatHistoryRound":
+			strVal := param.Input.Value.Content.(string)
+			int64Val, err := strconv.ParseInt(strVal, 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			p.ChatHistoryRound = int64Val
+		case "generationDiversity", "frequencyPenalty", "presencePenalty":
 		// do nothing
 		case "topP":
 			strVal := param.Input.Value.Content.(string)
@@ -590,11 +620,12 @@ func (c *Config) Build(ctx context.Context, ns *schema2.NodeSchema, _ ...schema2
 		inputs[knowledgeUserPromptTemplateKey] = &vo.TypeInfo{
 			Type: vo.DataTypeString,
 		}
-		sp := newPromptTpl(schema.System, c.SystemPrompt, inputs, nil)
-		up := newPromptTpl(schema.User, userPrompt, inputs, []string{knowledgeUserPromptTemplateKey})
+		sp := newPromptTpl(schema.System, c.SystemPrompt, inputs)
+		up := newPromptTpl(schema.User, userPrompt, inputs, withReservedKeys([]string{knowledgeUserPromptTemplateKey}), withAssociateUserInputFields(c.AssociateStartNodeUserInputFields))
 		template := newPrompts(sp, up, modelWithInfo)
+		templateWithChatHistory := newPromptsWithChatHistory(template, c.ChatHistorySetting)
 
-		_ = g.AddChatTemplateNode(templateNodeKey, template,
+		_ = g.AddChatTemplateNode(templateNodeKey, templateWithChatHistory,
 			compose.WithStatePreHandler(func(ctx context.Context, in map[string]any, state llmState) (map[string]any, error) {
 				for k, v := range state {
 					in[k] = v
@@ -604,10 +635,12 @@ func (c *Config) Build(ctx context.Context, ns *schema2.NodeSchema, _ ...schema2
 		_ = g.AddEdge(knowledgeLambdaKey, templateNodeKey)
 
 	} else {
-		sp := newPromptTpl(schema.System, c.SystemPrompt, ns.InputTypes, nil)
-		up := newPromptTpl(schema.User, userPrompt, ns.InputTypes, nil)
+		sp := newPromptTpl(schema.System, c.SystemPrompt, ns.InputTypes)
+		up := newPromptTpl(schema.User, userPrompt, ns.InputTypes, withAssociateUserInputFields(c.AssociateStartNodeUserInputFields))
 		template := newPrompts(sp, up, modelWithInfo)
-		_ = g.AddChatTemplateNode(templateNodeKey, template)
+		templateWithChatHistory := newPromptsWithChatHistory(template, c.ChatHistorySetting)
+
+		_ = g.AddChatTemplateNode(templateNodeKey, templateWithChatHistory)
 
 		_ = g.AddEdge(compose.START, templateNodeKey)
 	}
@@ -747,10 +780,11 @@ func (c *Config) Build(ctx context.Context, ns *schema2.NodeSchema, _ ...schema2
 	}
 
 	llm := &LLM{
-		r:                 r,
-		outputFormat:      format,
-		requireCheckpoint: requireCheckpoint,
-		fullSources:       ns.FullSources,
+		r:                  r,
+		outputFormat:       format,
+		requireCheckpoint:  requireCheckpoint,
+		fullSources:        ns.FullSources,
+		chatHistorySetting: c.ChatHistorySetting,
 	}
 
 	return llm, nil
@@ -825,10 +859,11 @@ func toRetrievalSearchType(s int64) (knowledge.SearchType, error) {
 }
 
 type LLM struct {
-	r                 compose.Runnable[map[string]any, map[string]any]
-	outputFormat      Format
-	requireCheckpoint bool
-	fullSources       map[string]*schema2.SourceInfo
+	r                  compose.Runnable[map[string]any, map[string]any]
+	outputFormat       Format
+	requireCheckpoint  bool
+	fullSources        map[string]*schema2.SourceInfo
+	chatHistorySetting *vo.ChatHistorySetting
 }
 
 const (
@@ -1193,6 +1228,68 @@ type ToolInterruptEventStore interface {
 	ResumeToolInterruptEvent(llmNodeKey vo.NodeKey, toolCallID string) (string, error)
 }
 
+func (l *LLM) ToCallbackInput(ctx context.Context, input map[string]any) (map[string]any, error) {
+	if l.chatHistorySetting == nil || !l.chatHistorySetting.EnableChatHistory {
+		return input, nil
+	}
+
+	var messages []*crossmessage.WfMessage
+	var scMessages []*schema.Message
+	var sectionID *int64
+	execCtx := execute.GetExeCtx(ctx)
+	if execCtx != nil {
+		messages = execCtx.ExeCfg.ConversationHistory
+		scMessages = execCtx.ExeCfg.ConversationHistorySchemaMessages
+		sectionID = execCtx.ExeCfg.SectionID
+	}
+
+	ret := map[string]any{
+		"chatHistory": []any{},
+	}
+	maps.Copy(ret, input)
+
+	if len(messages) == 0 {
+		return ret, nil
+	}
+
+	if sectionID != nil && messages[0].SectionID != *sectionID {
+		return ret, nil
+	}
+
+	maxRounds := int(l.chatHistorySetting.ChatHistoryRound)
+	if execCtx != nil && execCtx.ExeCfg.MaxHistoryRounds != nil {
+		maxRounds = min(int(*execCtx.ExeCfg.MaxHistoryRounds), maxRounds)
+	}
+	count := 0
+	startIdx := 0
+	for i := len(messages) - 1; i >= 0; i-- {
+		if messages[i].Role == schema.User {
+			count++
+		}
+		if count >= maxRounds {
+			startIdx = i
+			break
+		}
+	}
+
+	var historyMessages []any
+	for _, msg := range messages[startIdx:] {
+		content, err := nodes.ConvertMessageToString(ctx, msg)
+		if err != nil {
+			logs.CtxWarnf(ctx, "failed to convert message to string: %v", err)
+			continue
+		}
+		historyMessages = append(historyMessages, map[string]any{
+			"role":    string(msg.Role),
+			"content": content,
+		})
+	}
+	ctxcache.Store(ctx, chatHistoryKey, scMessages[startIdx:])
+
+	ret["chatHistory"] = historyMessages
+	return ret, nil
+}
+
 func (l *LLM) ToCallbackOutput(ctx context.Context, output map[string]any) (*nodes.StructuredCallbackOutput, error) {
 	c := execute.GetExeCtx(ctx)
 	if c == nil {

backend/domain/workflow/internal/nodes/llm/prompt.go

@@ -23,12 +23,14 @@ import (
 	"github.com/cloudwego/eino/components/prompt"
 	"github.com/cloudwego/eino/schema"
 
+	"github.com/coze-dev/coze-studio/backend/api/model/workflow"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/execute"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/internal/nodes"
 	schema2 "github.com/coze-dev/coze-studio/backend/domain/workflow/internal/schema"
 	"github.com/coze-dev/coze-studio/backend/infra/contract/modelmgr"
 	"github.com/coze-dev/coze-studio/backend/pkg/ctxcache"
+	"github.com/coze-dev/coze-studio/backend/pkg/logs"
 	"github.com/coze-dev/coze-studio/backend/pkg/sonic"
 )
 
@@ -38,12 +40,30 @@ type prompts struct {
 	mwi ModelWithInfo
 }
 
+type promptsWithChatHistory struct {
+	prompts *prompts
+	cfg     *vo.ChatHistorySetting
+}
+
+func withReservedKeys(keys []string) func(tpl *promptTpl) {
+	return func(tpl *promptTpl) {
+		tpl.reservedKeys = keys
+	}
+}
+
+func withAssociateUserInputFields(fs map[string]struct{}) func(tpl *promptTpl) {
+	return func(tpl *promptTpl) {
+		tpl.associateUserInputFields = fs
+	}
+}
+
 type promptTpl struct {
-	role          schema.RoleType
-	tpl           string
-	parts         []promptPart
-	hasMultiModal bool
-	reservedKeys  []string
+	role                     schema.RoleType
+	tpl                      string
+	parts                    []promptPart
+	hasMultiModal            bool
+	reservedKeys             []string
+	associateUserInputFields map[string]struct{}
 }
 
 type promptPart struct {
@@ -54,12 +74,20 @@ type promptPart struct {
 func newPromptTpl(role schema.RoleType,
 	tpl string,
 	inputTypes map[string]*vo.TypeInfo,
-	reservedKeys []string,
+	opts ...func(*promptTpl),
 ) *promptTpl {
 	if len(tpl) == 0 {
 		return nil
 	}
 
+	pTpl := &promptTpl{
+		role: role,
+		tpl:  tpl,
+	}
+	for _, opt := range opts {
+		opt(pTpl)
+	}
+
 	parts := nodes.ParseTemplate(tpl)
 	promptParts := make([]promptPart, 0, len(parts))
 	hasMultiModal := false
@@ -87,14 +115,10 @@ func newPromptTpl(role schema.RoleType,
 
 		hasMultiModal = true
 	}
+	pTpl.parts = promptParts
+	pTpl.hasMultiModal = hasMultiModal
 
-	return &promptTpl{
-		role:          role,
-		tpl:           tpl,
-		parts:         promptParts,
-		hasMultiModal: hasMultiModal,
-		reservedKeys:  reservedKeys,
-	}
+	return pTpl
 }
 
 const sourceKey = "sources_%s"
@@ -107,23 +131,53 @@ func newPrompts(sp, up *promptTpl, model ModelWithInfo) *prompts {
 	}
 }
 
+func newPromptsWithChatHistory(prompts *prompts, cfg *vo.ChatHistorySetting) *promptsWithChatHistory {
+	return &promptsWithChatHistory{
+		prompts: prompts,
+		cfg:     cfg,
+	}
+}
+
 func (pl *promptTpl) render(ctx context.Context, vs map[string]any,
 	sources map[string]*schema2.SourceInfo,
 	supportedModals map[modelmgr.Modal]bool,
 ) (*schema.Message, error) {
-	if !pl.hasMultiModal || len(supportedModals) == 0 {
-		var opts []nodes.RenderOption
-		if len(pl.reservedKeys) > 0 {
-			opts = append(opts, nodes.WithReservedKey(pl.reservedKeys...))
+	isChatFlow := execute.GetExeCtx(ctx).ExeCfg.WorkflowMode == workflow.WorkflowMode_ChatFlow
+	userMessage := execute.GetExeCtx(ctx).ExeCfg.UserMessage
+
+	if !isChatFlow {
+		if !pl.hasMultiModal || len(supportedModals) == 0 {
+			var opts []nodes.RenderOption
+			if len(pl.reservedKeys) > 0 {
+				opts = append(opts, nodes.WithReservedKey(pl.reservedKeys...))
+			}
+			r, err := nodes.Render(ctx, pl.tpl, vs, sources, opts...)
+			if err != nil {
+				return nil, err
+			}
+			return &schema.Message{
+				Role:    pl.role,
+				Content: r,
+			}, nil
 		}
-		r, err := nodes.Render(ctx, pl.tpl, vs, sources, opts...)
-		if err != nil {
-			return nil, err
+	} else {
+		if (!pl.hasMultiModal || len(supportedModals) == 0) &&
+			(len(pl.associateUserInputFields) == 0 ||
+				(len(pl.associateUserInputFields) > 0 && userMessage != nil && userMessage.MultiContent == nil)) {
+			var opts []nodes.RenderOption
+			if len(pl.reservedKeys) > 0 {
+				opts = append(opts, nodes.WithReservedKey(pl.reservedKeys...))
+			}
+			r, err := nodes.Render(ctx, pl.tpl, vs, sources, opts...)
+			if err != nil {
+				return nil, err
+			}
+			return &schema.Message{
+				Role:    pl.role,
+				Content: r,
+			}, nil
 		}
-		return &schema.Message{
-			Role:    pl.role,
-			Content: r,
-		}, nil
+
 	}
 
 	multiParts := make([]schema.ChatMessagePart, 0, len(pl.parts))
@@ -141,6 +195,13 @@ func (pl *promptTpl) render(ctx context.Context, vs map[string]any,
 			continue
 		}
 
+		if _, ok := pl.associateUserInputFields[part.part.Value]; ok && userMessage != nil && isChatFlow {
+			for _, p := range userMessage.MultiContent {
+				multiParts = append(multiParts, transformMessagePart(p, supportedModals))
+			}
+			continue
+		}
+
 		skipped, invalid := part.part.Skipped(sources)
 		if invalid {
 			var reserved bool
@@ -164,6 +225,7 @@ func (pl *promptTpl) render(ctx context.Context, vs map[string]any,
 		if err != nil {
 			return nil, err
 		}
+
 		if part.fileType == nil {
 			multiParts = append(multiParts, schema.ChatMessagePart{
 				Type: schema.ChatMessagePartTypeText,
@@ -172,64 +234,38 @@ func (pl *promptTpl) render(ctx context.Context, vs map[string]any,
 			continue
 		}
 
+		var originalPart schema.ChatMessagePart
 		switch *part.fileType {
 		case vo.FileTypeImage, vo.FileTypeSVG:
-			if _, ok := supportedModals[modelmgr.ModalImage]; !ok {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeText,
-					Text: r,
-				})
-			} else {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeImageURL,
-					ImageURL: &schema.ChatMessageImageURL{
-						URL: r,
-					},
-				})
+			originalPart = schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeImageURL,
+				ImageURL: &schema.ChatMessageImageURL{
+					URL: r,
+				},
 			}
 		case vo.FileTypeAudio, vo.FileTypeVoice:
-			if _, ok := supportedModals[modelmgr.ModalAudio]; !ok {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeText,
-					Text: r,
-				})
-			} else {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeAudioURL,
-					AudioURL: &schema.ChatMessageAudioURL{
-						URL: r,
-					},
-				})
+			originalPart = schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeAudioURL,
+				AudioURL: &schema.ChatMessageAudioURL{
+					URL: r,
+				},
 			}
 		case vo.FileTypeVideo:
-			if _, ok := supportedModals[modelmgr.ModalVideo]; !ok {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeText,
-					Text: r,
-				})
-			} else {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeVideoURL,
-					VideoURL: &schema.ChatMessageVideoURL{
-						URL: r,
-					},
-				})
+			originalPart = schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeVideoURL,
+				VideoURL: &schema.ChatMessageVideoURL{
+					URL: r,
+				},
 			}
 		default:
-			if _, ok := supportedModals[modelmgr.ModalFile]; !ok {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeText,
-					Text: r,
-				})
-			} else {
-				multiParts = append(multiParts, schema.ChatMessagePart{
-					Type: schema.ChatMessagePartTypeFileURL,
-					FileURL: &schema.ChatMessageFileURL{
-						URL: r,
-					},
-				})
+			originalPart = schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeFileURL,
+				FileURL: &schema.ChatMessageFileURL{
+					URL: r,
+				},
 			}
 		}
+		multiParts = append(multiParts, transformMessagePart(originalPart, supportedModals))
 	}
 
 	return &schema.Message{
@@ -238,6 +274,40 @@ func (pl *promptTpl) render(ctx context.Context, vs map[string]any,
 	}, nil
 }
 
+func transformMessagePart(part schema.ChatMessagePart, supportedModals map[modelmgr.Modal]bool) schema.ChatMessagePart {
+	switch part.Type {
+	case schema.ChatMessagePartTypeImageURL:
+		if _, ok := supportedModals[modelmgr.ModalImage]; !ok {
+			return schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeText,
+				Text: part.ImageURL.URL,
+			}
+		}
+	case schema.ChatMessagePartTypeAudioURL:
+		if _, ok := supportedModals[modelmgr.ModalAudio]; !ok {
+			return schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeText,
+				Text: part.AudioURL.URL,
+			}
+		}
+	case schema.ChatMessagePartTypeVideoURL:
+		if _, ok := supportedModals[modelmgr.ModalVideo]; !ok {
+			return schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeText,
+				Text: part.VideoURL.URL,
+			}
+		}
+	case schema.ChatMessagePartTypeFileURL:
+		if _, ok := supportedModals[modelmgr.ModalFile]; !ok {
+			return schema.ChatMessagePart{
+				Type: schema.ChatMessagePartTypeText,
+				Text: part.FileURL.URL,
+			}
+		}
+	}
+	return part
+}
+
 func (p *prompts) Format(ctx context.Context, vs map[string]any, _ ...prompt.Option) (
 	_ []*schema.Message, err error,
 ) {
@@ -288,3 +358,45 @@ func (p *prompts) Format(ctx context.Context, vs map[string]any, _ ...prompt.Opt
 
 	return []*schema.Message{systemMsg, userMsg}, nil
 }
+
+func (p *promptsWithChatHistory) Format(ctx context.Context, vs map[string]any, _ ...prompt.Option) (
+	[]*schema.Message, error) {
+	baseMessages, err := p.prompts.Format(ctx, vs)
+	if err != nil {
+		return nil, err
+	}
+	if p.cfg == nil || !p.cfg.EnableChatHistory {
+		return baseMessages, nil
+	}
+
+	exeCtx := execute.GetExeCtx(ctx)
+	if exeCtx == nil {
+		logs.CtxWarnf(ctx, "execute context is nil, skipping chat history")
+		return baseMessages, nil
+	}
+
+	if exeCtx.ExeCfg.WorkflowMode != workflow.WorkflowMode_ChatFlow {
+		return baseMessages, nil
+	}
+
+	historyMessages, ok := ctxcache.Get[[]*schema.Message](ctx, chatHistoryKey)
+
+	if !ok || len(historyMessages) == 0 {
+		logs.CtxWarnf(ctx, "conversation history is empty")
+		return baseMessages, nil
+	}
+
+	if len(historyMessages) == 0 {
+		return baseMessages, nil
+	}
+
+	finalMessages := make([]*schema.Message, 0, len(baseMessages)+len(historyMessages))
+	if len(baseMessages) > 0 && baseMessages[0].Role == schema.System {
+		finalMessages = append(finalMessages, baseMessages[0])
+		baseMessages = baseMessages[1:]
+	}
+	finalMessages = append(finalMessages, historyMessages...)
+	finalMessages = append(finalMessages, baseMessages...)
+
+	return finalMessages, nil
+}

backend/domain/workflow/internal/nodes/utils.go

@@ -17,14 +17,17 @@
 package nodes
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"maps"
 	"reflect"
 	"strings"
 
 	"github.com/cloudwego/eino/compose"
-
+	crossmessage "github.com/coze-dev/coze-studio/backend/crossdomain/contract/message"
 	"github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
 	"github.com/coze-dev/coze-studio/backend/pkg/logs"
 	"github.com/coze-dev/coze-studio/backend/pkg/sonic"
 	"github.com/coze-dev/coze-studio/backend/types/errno"
@@ -279,3 +282,30 @@ func GetConcatFunc(typ reflect.Type) func(reflect.Value) (reflect.Value, error)
 
 	return nil
 }
+
+func ConvertMessageToString(_ context.Context, msg *crossmessage.WfMessage) (string, error) {
+	if msg.MultiContent != nil {
+		var textContents []string
+		var otherContents []string
+		for _, m := range msg.MultiContent {
+			if m.Text != nil {
+				textContents = append(textContents, ptr.From(m.Text))
+			} else if m.Uri != nil {
+				otherContents = append(otherContents, ptr.From(m.Url))
+			}
+		}
+
+		var allParts []string
+		if len(textContents) > 0 {
+			allParts = append(allParts, textContents...)
+		}
+		if len(otherContents) > 0 {
+			allParts = append(allParts, otherContents...)
+		}
+		return strings.Join(allParts, ","), nil
+	} else if msg.Text != nil {
+		return ptr.From(msg.Text), nil
+	} else {
+		return "", vo.WrapError(errno.ErrInvalidParameter, errors.New("message is invalid"))
+	}
+}