@@ -136,6 +129,12 @@ const markdownTokens = computed(() => {
return marked.lexer(safeMarkdown);
});
+// 计算属性:判断是否有实际内容(非空且不只是空白)
+const hasActualContent = computed(() => {
+ const text = props.content || props.session?.content || '';
+ return text && text.trim().length > 0;
+});
+
// 渲染单个 token 为 HTML
const renderToken = (token) => {
try {
@@ -428,8 +427,7 @@ onBeforeUnmount(() => {
}
.thinking-loading {
- margin-left: 16px;
- margin-bottom: 8px;
+ padding: 8px 0;
}
.loading-typing {
diff --git a/frontend/src/views/chat/components/deepThink.vue b/frontend/src/views/chat/components/deepThink.vue
index 67745dbf..74194ac8 100644
--- a/frontend/src/views/chat/components/deepThink.vue
+++ b/frontend/src/views/chat/components/deepThink.vue
@@ -1,38 +1,32 @@
-
-
-
-
-
-
-
-
-
-
-

{{ $t('chat.thinking') }}
-
-
-

{{ $t('chat.deepThoughtCompleted') }}
-
-
-
-
-
-
-
-
-
-
+
+
\ No newline at end of file
+
diff --git a/frontend/src/views/chat/index.vue b/frontend/src/views/chat/index.vue
index ebe4bcd8..2226208e 100644
--- a/frontend/src/views/chat/index.vue
+++ b/frontend/src/views/chat/index.vue
@@ -243,12 +243,21 @@ const handleMsgList = async (data, isScrollType = false, newScrollHeight) => {
item.thinkContent = "";
item.content = item.content;
item.showThink = false;
+ item.thinking = false;
} else if (item.content.includes('<\/think>')) {
+ // 历史消息中包含完整的
... 标签,说明 thinking 已完成
const arr = item.content.trim().split('<\/think>');
item.showThink = true;
+ item.thinking = false; // 关键:标记 thinking 已完成,使 deepThink 默认折叠
item.thinkContent = arr[0].trim().replace('
', '');
let index = item.content.trim().lastIndexOf('<\/think>')
item.content = item.content.substring(index + 8);
+ } else if (item.content.includes('')) {
+ // 内容包含 但没有 ,说明 thinking 还在进行中(不太可能出现在历史消息中)
+ item.showThink = true;
+ item.thinking = true;
+ item.thinkContent = item.content.replace('', '').trim();
+ item.content = '';
}
}
@@ -408,16 +417,55 @@ onChunk((data) => {
}
// 判断是否是 Agent 模式的响应
- const isAgentResponse = data.response_type === 'thinking' ||
- data.response_type === 'tool_call' ||
- data.response_type === 'tool_result' ||
- data.response_type === 'references' ||
- data.response_type === 'answer' ||
- data.response_type === 'reflection' ||
- data.response_type === 'stop';
+ // 注意:'answer', 'complete', 'references' 类型可能在两种模式下都存在
+ // 只有 'thinking', 'tool_call', 'tool_result', 'reflection' 是 Agent 专有的
+ const isAgentOnlyResponse = data.response_type === 'thinking' ||
+ data.response_type === 'tool_call' ||
+ data.response_type === 'tool_result' ||
+ data.response_type === 'reflection';
+
+ // 检查当前消息是否已经是 Agent 模式
+ const lastMessage = messagesList[messagesList.length - 1];
+ const isCurrentlyAgentMode = lastMessage?.isAgentMode === true;
+
+ // 如果是 Agent 专有的响应类型,或者当前消息已经是 Agent 模式,则走 Agent 处理
+ const shouldHandleAsAgent = isAgentOnlyResponse || isCurrentlyAgentMode;
+
+ // 处理 references 事件 - 在两种模式下都需要处理,但不改变模式
+ if (data.response_type === 'references') {
+ // 如果当前是 Agent 模式,走 Agent 处理
+ if (isCurrentlyAgentMode) {
+ handleAgentChunk(data);
+ return;
+ }
+ // 非 Agent 模式:将 references 保存到消息中供 botmsg 使用
+ let existingMessage = messagesList.findLast((item) => item.request_id === data.id || item.id === data.id);
+
+ // 如果消息还不存在,先创建一个空的 assistant 消息
+ if (!existingMessage) {
+ existingMessage = {
+ id: data.id,
+ request_id: data.id,
+ role: 'assistant',
+ content: '',
+ showThink: false,
+ thinkContent: '',
+ thinking: false,
+ is_completed: false,
+ knowledge_references: []
+ };
+ messagesList.push(existingMessage);
+ loading.value = false; // 消息已创建,关闭 loading
+ scrollToBottom();
+ }
+
+ existingMessage.knowledge_references = data.knowledge_references || data.data?.references || [];
+ console.log('[References] Saved to message, count:', existingMessage.knowledge_references.length);
+ return;
+ }
// Agent 模式处理(包括 stop 事件)
- if (isAgentResponse || messagesList[messagesList.length - 1]?.isAgentMode) {
+ if (shouldHandleAsAgent) {
// 在 handleAgentChunk 中处理 loading 状态
handleAgentChunk(data);
@@ -432,7 +480,23 @@ onChunk((data) => {
return;
}
- // 原有的知识库 QA 处理逻辑
+ // 原有的知识库 QA 处理逻辑(非 Agent 模式)
+ // answer 内容中可能包含 ... 标签
+
+ // 检查消息是否已经完成,如果已完成则忽略后续的完成事件(防止空内容覆盖)
+ const existingMessage = messagesList.findLast((item) => {
+ if (item.request_id === data.id) {
+ return true
+ }
+ return item.id === data.id;
+ });
+
+ // 如果消息已完成且当前事件是完成事件(done=true 且无内容),直接忽略
+ if (existingMessage?.is_completed && data.done && !data.content) {
+ console.log('[Non-Agent] Ignoring duplicate completion event for completed message');
+ return;
+ }
+
fullContent.value += data.content;
let obj = { ...data, content: '', role: 'assistant', showThink: false, is_completed: false };
@@ -451,13 +515,6 @@ onChunk((data) => {
obj.content = fullContent.value;
}
- // 检查是否已有消息,如果没有则说明这是第一次,关闭 loading
- const existingMessage = messagesList.findLast((item) => {
- if (item.request_id === obj.id) {
- return true
- }
- return item.id === obj.id;
- });
if (!existingMessage) {
loading.value = false; // 消息即将创建,关闭 loading
}
@@ -704,8 +761,20 @@ const handleAgentChunk = (data) => {
case 'answer':
// 最终答案
message.thinking = false;
- message.content = (message.content || '') + (data.content || '');
- fullContent.value += data.content || '';
+
+ console.log('[Answer Event] Received:', {
+ has_content: !!data.content,
+ content_length: data.content?.length || 0,
+ done: data.done,
+ current_message_content_length: message.content?.length || 0
+ });
+
+ // 只有当有实际内容时才追加,避免空内容覆盖
+ if (data.content) {
+ message.content = (message.content || '') + data.content;
+ fullContent.value += data.content;
+ console.log('[Answer] Content appended, new length:', message.content.length);
+ }
// Add or update answer event in agentEventStream
if (!message.agentEventStream) message.agentEventStream = [];
@@ -718,13 +787,19 @@ const handleAgentChunk = (data) => {
done: false
};
message.agentEventStream.push(answerEvent);
+ console.log('[Answer] Created new answer event in stream');
}
- answerEvent.content = message.content;
- answerEvent.done = data.done;
+ // 只有当有实际内容时才更新 answerEvent.content
+ if (data.content) {
+ answerEvent.content = message.content;
+ console.log('[Answer] answerEvent.content updated, length:', answerEvent.content.length);
+ }
- if (data.done) {
- console.log('[Agent] Answer done, content length:', message.content?.length || 0);
+ // 只在第一次收到 done:true 时标记完成,忽略后续重复的完成事件
+ if (data.done && !answerEvent.done) {
+ answerEvent.done = true;
+ console.log('[Agent] Answer done, content length:', message.content?.length || 0, 'answerEvent.content length:', answerEvent.content?.length || 0);
// 完成 - 关闭所有状态
loading.value = false;
@@ -735,9 +810,19 @@ const handleAgentChunk = (data) => {
// 标题生成已改为异步事件推送,不再需要在这里手动调用
// 如果标题还未生成,前端会通过 SSE 事件接收
+ } else if (data.done && answerEvent.done) {
+ console.log('[Answer] Ignoring duplicate done event, current content preserved:', answerEvent.content?.length || 0);
}
break;
+ case 'complete':
+ // 整个流式响应完成事件 - 确保状态正确关闭
+ console.log('[Agent] Complete event received');
+ loading.value = false;
+ isReplying.value = false;
+ // 不清空 message.content,保持已有内容
+ break;
+
case 'stop':
// 停止事件 - 添加到事件流并标记对话完成
console.log('[Agent] Stop event received');
diff --git a/internal/agent/engine.go b/internal/agent/engine.go
index 46739685..3c923af1 100644
--- a/internal/agent/engine.go
+++ b/internal/agent/engine.go
@@ -688,12 +688,13 @@ func (e *AgentEngine) streamThinkingToEventBus(
iteration int,
sessionID string,
) (*types.ChatResponse, error) {
- logger.Infof(ctx, "[Agent][Thinking][Iteration-%d] Starting thinking stream with temperature=%.2f, tools=%d",
- iteration+1, e.config.Temperature, len(tools))
+ logger.Infof(ctx, "[Agent][Thinking][Iteration-%d] Starting thinking stream with temperature=%.2f, tools=%d, thinking=%v",
+ iteration+1, e.config.Temperature, len(tools), e.config.Thinking)
opts := &chat.ChatOptions{
Temperature: e.config.Temperature,
Tools: tools,
+ Thinking: e.config.Thinking,
}
logger.Debug(context.Background(), "[Agent] streamLLM opts tool_choice=auto temperature=", e.config.Temperature)
@@ -832,7 +833,7 @@ func (e *AgentEngine) streamFinalAnswerToEventBus(
fullAnswer, _, err := e.streamLLMToEventBus(
ctx,
messages,
- &chat.ChatOptions{Temperature: e.config.Temperature},
+ &chat.ChatOptions{Temperature: e.config.Temperature, Thinking: e.config.Thinking},
func(chunk *types.StreamResponse, fullContent string) {
if chunk.Content != "" {
logger.Debugf(ctx, "[Agent][FinalAnswer] Emitting answer chunk: %d chars", len(chunk.Content))
diff --git a/internal/application/service/chat_pipline/chat_completion_stream.go b/internal/application/service/chat_pipline/chat_completion_stream.go
index 507415e1..f618d6c9 100644
--- a/internal/application/service/chat_pipline/chat_completion_stream.go
+++ b/internal/application/service/chat_pipline/chat_completion_stream.go
@@ -99,9 +99,13 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
})
// Start goroutine to consume channel and emit events directly
+ // For non-agent mode, thinking content is embedded in answer stream with tags
+ // This ensures consistent display between streaming and history loading
go func() {
answerID := fmt.Sprintf("%s-answer", uuid.New().String()[:8])
var finalContent string
+ var thinkingStarted bool
+ var thinkingEnded bool
for response := range responseChan {
// Handle error responses from the stream
@@ -122,8 +126,53 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
continue
}
+ // For non-agent mode: embed thinking content with tags in answer stream
+ // This ensures the frontend uses deepThink.vue component consistently
+ if response.ResponseType == types.ResponseTypeThinking {
+ content := response.Content
+ // Add tag at the beginning of thinking content
+ if !thinkingStarted {
+ content = "" + content
+ thinkingStarted = true
+ }
+ // Add tag at the end of thinking content
+ if response.Done && !thinkingEnded {
+ content = content + ""
+ thinkingEnded = true
+ }
+ finalContent += content
+ if err := eventBus.Emit(ctx, types.Event{
+ ID: answerID,
+ Type: types.EventType(event.EventAgentFinalAnswer),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentFinalAnswerData{
+ Content: content,
+ Done: false, // Thinking is not the final answer
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit thinking as answer event: %v", err)
+ }
+ continue
+ }
+
// Emit event for each answer chunk
if response.ResponseType == types.ResponseTypeAnswer {
+ // If we had thinking but it wasn't explicitly ended, close the think tag
+ if thinkingStarted && !thinkingEnded {
+ thinkingEnded = true
+ finalContent += ""
+ if err := eventBus.Emit(ctx, types.Event{
+ ID: answerID,
+ Type: types.EventType(event.EventAgentFinalAnswer),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentFinalAnswerData{
+ Content: "",
+ Done: false,
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit think close tag: %v", err)
+ }
+ }
finalContent += response.Content
if err := eventBus.Emit(ctx, types.Event{
ID: answerID,
diff --git a/internal/application/service/session.go b/internal/application/service/session.go
index d83136c4..fd6b8563 100644
--- a/internal/application/service/session.go
+++ b/internal/application/service/session.go
@@ -487,6 +487,12 @@ func (s *sessionService) KnowledgeQA(
summaryConfig.MaxCompletionTokens = customAgent.Config.MaxCompletionTokens
logger.Infof(ctx, "Using custom agent's max_completion_tokens: %d", customAgent.Config.MaxCompletionTokens)
}
+ // Override thinking mode from agent config
+ // Agent-level thinking setting takes full control (no global fallback)
+ summaryConfig.Thinking = customAgent.Config.Thinking
+ if customAgent.Config.Thinking != nil {
+ logger.Infof(ctx, "Using custom agent's thinking: %v", *customAgent.Config.Thinking)
+ }
// Override retrieval strategy settings
if customAgent.Config.EmbeddingTopK > 0 {
embeddingTopK = customAgent.Config.EmbeddingTopK
@@ -1104,6 +1110,7 @@ func (s *sessionService) AgentQA(
HistoryTurns: customAgent.Config.HistoryTurns,
MCPSelectionMode: customAgent.Config.MCPSelectionMode,
MCPServices: customAgent.Config.MCPServices,
+ Thinking: customAgent.Config.Thinking,
}
// Resolve knowledge bases: request-level @ mentions take priority over agent config
diff --git a/internal/handler/session/helpers.go b/internal/handler/session/helpers.go
index 49a6601f..d0cd6614 100644
--- a/internal/handler/session/helpers.go
+++ b/internal/handler/session/helpers.go
@@ -96,14 +96,14 @@ func buildStreamResponse(evt interfaces.StreamEvent, requestID string) *types.St
}
// sendCompletionEvent sends a final completion event to the client
+// NOTE: This is now a no-op because:
+// 1. The 'complete' event from handleComplete already signals stream completion
+// 2. Sending an extra empty 'answer' event with done:true causes frontend issues
+// (multiple done events can confuse state management)
+// The frontend should use 'complete' response_type to detect stream completion
func sendCompletionEvent(c *gin.Context, requestID string) {
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeAnswer,
- Content: "",
- Done: true,
- })
- c.Writer.Flush()
+ // Intentionally empty - completion is signaled by the 'complete' event
+ // which is already sent before this function is called
}
// createAgentQueryEvent creates a standard agent query event
diff --git a/internal/handler/session/qa.go b/internal/handler/session/qa.go
index cb2ff297..44360dd3 100644
--- a/internal/handler/session/qa.go
+++ b/internal/handler/session/qa.go
@@ -323,6 +323,10 @@ func (h *Handler) executeNormalModeQA(reqCtx *qaRequestContext, generateTitle bo
streamCtx := h.setupSSEStream(reqCtx, generateTitle)
// Setup completion handler for normal mode
+ // Note: Thinking content is now embedded in answer stream with tags
+ // by chat_completion_stream.go, so we don't need separate thinking event handling
+ var completionHandled bool // Prevent duplicate completion handling
+
streamCtx.eventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error {
data, ok := evt.Data.(event.AgentFinalAnswerData)
if !ok {
@@ -330,14 +334,22 @@ func (h *Handler) executeNormalModeQA(reqCtx *qaRequestContext, generateTitle bo
}
streamCtx.assistantMessage.Content += data.Content
if data.Done {
+ // Prevent duplicate completion handling
+ if completionHandled {
+ return nil
+ }
+ completionHandled = true
+
logger.Infof(streamCtx.asyncCtx, "Knowledge QA service completed for session: %s", sessionID)
+ // Content already contains ... tags from chat_completion_stream.go
h.completeAssistantMessage(streamCtx.asyncCtx, streamCtx.assistantMessage)
+ // Emit EventAgentComplete - this will trigger handleComplete which sends the SSE complete event
+ // Note: Don't cancel context here, let the SSE handler close naturally after receiving the complete event
streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{
Type: event.EventAgentComplete,
SessionID: sessionID,
Data: event.AgentCompleteData{FinalAnswer: streamCtx.assistantMessage.Content},
})
- streamCtx.cancel()
}
return nil
})
diff --git a/internal/models/chat/chat.go b/internal/models/chat/chat.go
index a0cb3489..781804fb 100644
--- a/internal/models/chat/chat.go
+++ b/internal/models/chat/chat.go
@@ -6,6 +6,7 @@ import (
"fmt"
"strings"
+ "github.com/Tencent/WeKnora/internal/models/provider"
"github.com/Tencent/WeKnora/internal/models/utils/ollama"
"github.com/Tencent/WeKnora/internal/types"
)
@@ -87,18 +88,41 @@ type ChatConfig struct {
// NewChat 创建聊天实例
func NewChat(config *ChatConfig, ollamaService *ollama.OllamaService) (Chat, error) {
- var chat Chat
- var err error
switch strings.ToLower(string(config.Source)) {
case string(types.ModelSourceLocal):
- chat, err = NewOllamaChat(config, ollamaService)
- if err != nil {
- return nil, err
- }
- return chat, nil
+ return NewOllamaChat(config, ollamaService)
case string(types.ModelSourceRemote):
- return NewRemoteAPIChat(config)
+ return NewRemoteChat(config)
default:
return nil, fmt.Errorf("unsupported chat model source: %s", config.Source)
}
}
+
+// NewRemoteChat 根据 provider 创建远程聊天实例
+func NewRemoteChat(config *ChatConfig) (Chat, error) {
+ providerName := provider.ProviderName(config.Provider)
+ if providerName == "" {
+ providerName = provider.DetectProvider(config.BaseURL)
+ }
+
+ switch providerName {
+ case provider.ProviderLKEAP:
+ // LKEAP 有特殊的 thinking 参数格式
+ return NewLKEAPChat(config)
+ case provider.ProviderAliyun:
+ // 检查是否为 Qwen3 模型(需要特殊处理 enable_thinking)
+ if provider.IsQwen3Model(config.ModelName) {
+ return NewQwenChat(config)
+ }
+ return NewRemoteAPIChat(config)
+ case provider.ProviderDeepSeek:
+ // DeepSeek 不支持 tool_choice
+ return NewDeepSeekChat(config)
+ case provider.ProviderGeneric:
+ // Generic provider (如 vLLM) 使用 ChatTemplateKwargs
+ return NewGenericChat(config)
+ default:
+ // 其他 provider 使用标准 OpenAI 兼容实现
+ return NewRemoteAPIChat(config)
+ }
+}
diff --git a/internal/models/chat/lkeap.go b/internal/models/chat/lkeap.go
new file mode 100644
index 00000000..395a7e60
--- /dev/null
+++ b/internal/models/chat/lkeap.go
@@ -0,0 +1,77 @@
+package chat
+
+import (
+ "strings"
+
+ "github.com/Tencent/WeKnora/internal/models/provider"
+ "github.com/sashabaranov/go-openai"
+)
+
+// LKEAPChat 腾讯云知识引擎原子能力 (LKEAP) 聊天实现
+// 支持 DeepSeek-R1, DeepSeek-V3 系列模型,具备思维链能力
+// 参考:https://cloud.tencent.com/document/product/1772/115963
+//
+// 与标准 OpenAI API 的区别:
+// 1. thinking 参数格式不同:LKEAP 使用 {"type": "enabled"/"disabled"}
+// 2. 仅 DeepSeek V3.x 系列需要显式设置 thinking 参数,R1 系列默认开启
+type LKEAPChat struct {
+ *RemoteAPIChat
+}
+
+// LKEAPThinkingConfig 思维链配置(LKEAP 特有格式)
+type LKEAPThinkingConfig struct {
+ Type string `json:"type"` // "enabled" 或 "disabled"
+}
+
+// LKEAPChatCompletionRequest LKEAP 自定义请求结构体
+type LKEAPChatCompletionRequest struct {
+ openai.ChatCompletionRequest
+ Thinking *LKEAPThinkingConfig `json:"thinking,omitempty"` // 思维链开关(仅 V3.x 系列)
+}
+
+// NewLKEAPChat 创建 LKEAP 聊天实例
+func NewLKEAPChat(config *ChatConfig) (*LKEAPChat, error) {
+ // 确保 provider 设置正确
+ config.Provider = string(provider.ProviderLKEAP)
+
+ remoteChat, err := NewRemoteAPIChat(config)
+ if err != nil {
+ return nil, err
+ }
+
+ chat := &LKEAPChat{
+ RemoteAPIChat: remoteChat,
+ }
+
+ // 设置请求自定义器,添加 LKEAP 特有的 thinking 参数
+ remoteChat.SetRequestCustomizer(chat.customizeRequest)
+
+ return chat, nil
+}
+
+// isDeepSeekV3Model 检查是否为 DeepSeek V3.x 系列模型
+func (c *LKEAPChat) isDeepSeekV3Model() bool {
+ return strings.Contains(strings.ToLower(c.GetModelName()), "deepseek-v3")
+}
+
+// customizeRequest 自定义 LKEAP 请求
+func (c *LKEAPChat) customizeRequest(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (any, bool) {
+ // 仅对 DeepSeek V3.x 系列模型需要特殊处理 thinking 参数
+ // R1 系列模型默认开启思维链,无需额外参数
+ if !c.isDeepSeekV3Model() || opts == nil || opts.Thinking == nil {
+ return nil, false // 使用标准请求
+ }
+
+ // 构建 LKEAP 特有请求
+ lkeapReq := LKEAPChatCompletionRequest{
+ ChatCompletionRequest: *req,
+ }
+
+ thinkingType := "disabled"
+ if *opts.Thinking {
+ thinkingType = "enabled"
+ }
+ lkeapReq.Thinking = &LKEAPThinkingConfig{Type: thinkingType}
+
+ return lkeapReq, true // 使用原始 HTTP 请求
+}
diff --git a/internal/models/chat/provider_chat.go b/internal/models/chat/provider_chat.go
new file mode 100644
index 00000000..71837dba
--- /dev/null
+++ b/internal/models/chat/provider_chat.go
@@ -0,0 +1,82 @@
+package chat
+
+import (
+ "context"
+
+ "github.com/Tencent/WeKnora/internal/logger"
+ "github.com/Tencent/WeKnora/internal/models/provider"
+ "github.com/sashabaranov/go-openai"
+)
+
+// DeepSeekChat DeepSeek 模型聊天实现
+// DeepSeek 模型不支持 tool_choice 参数
+type DeepSeekChat struct {
+ *RemoteAPIChat
+}
+
+// NewDeepSeekChat 创建 DeepSeek 聊天实例
+func NewDeepSeekChat(config *ChatConfig) (*DeepSeekChat, error) {
+ config.Provider = string(provider.ProviderDeepSeek)
+
+ remoteChat, err := NewRemoteAPIChat(config)
+ if err != nil {
+ return nil, err
+ }
+
+ chat := &DeepSeekChat{
+ RemoteAPIChat: remoteChat,
+ }
+
+ // 设置请求自定义器
+ remoteChat.SetRequestCustomizer(chat.customizeRequest)
+
+ return chat, nil
+}
+
+// customizeRequest 自定义 DeepSeek 请求
+func (c *DeepSeekChat) customizeRequest(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (any, bool) {
+ // DeepSeek 模型不支持 tool_choice,需要清除
+ if opts != nil && opts.ToolChoice != "" {
+ logger.Infof(context.Background(), "deepseek model, skip tool_choice")
+ req.ToolChoice = nil
+ }
+ return nil, false
+}
+
+// GenericChat 通用 OpenAI 兼容实现(如 vLLM)
+// 支持 ChatTemplateKwargs 参数
+type GenericChat struct {
+ *RemoteAPIChat
+}
+
+// NewGenericChat 创建通用聊天实例
+func NewGenericChat(config *ChatConfig) (*GenericChat, error) {
+ config.Provider = string(provider.ProviderGeneric)
+
+ remoteChat, err := NewRemoteAPIChat(config)
+ if err != nil {
+ return nil, err
+ }
+
+ chat := &GenericChat{
+ RemoteAPIChat: remoteChat,
+ }
+
+ // 设置请求自定义器
+ remoteChat.SetRequestCustomizer(chat.customizeRequest)
+
+ return chat, nil
+}
+
+// customizeRequest 自定义 Generic 请求
+func (c *GenericChat) customizeRequest(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (any, bool) {
+ // Generic provider(如 vLLM)使用 ChatTemplateKwargs 传递 thinking 参数
+ thinking := false
+ if opts != nil && opts.Thinking != nil {
+ thinking = *opts.Thinking
+ }
+ req.ChatTemplateKwargs = map[string]interface{}{
+ "enable_thinking": thinking,
+ }
+ return nil, false // 使用标准请求(已修改)
+}
diff --git a/internal/models/chat/qwen.go b/internal/models/chat/qwen.go
new file mode 100644
index 00000000..9fca5d09
--- /dev/null
+++ b/internal/models/chat/qwen.go
@@ -0,0 +1,62 @@
+package chat
+
+import (
+ "github.com/Tencent/WeKnora/internal/models/provider"
+ "github.com/sashabaranov/go-openai"
+)
+
+// QwenChat 阿里云 Qwen 模型聊天实现
+// Qwen3 模型需要特殊处理 enable_thinking 参数
+type QwenChat struct {
+ *RemoteAPIChat
+}
+
+// QwenChatCompletionRequest Qwen 模型的自定义请求结构体
+type QwenChatCompletionRequest struct {
+ openai.ChatCompletionRequest
+ EnableThinking *bool `json:"enable_thinking,omitempty"`
+}
+
+// NewQwenChat 创建 Qwen 聊天实例
+func NewQwenChat(config *ChatConfig) (*QwenChat, error) {
+ config.Provider = string(provider.ProviderAliyun)
+
+ remoteChat, err := NewRemoteAPIChat(config)
+ if err != nil {
+ return nil, err
+ }
+
+ chat := &QwenChat{
+ RemoteAPIChat: remoteChat,
+ }
+
+ // 设置请求自定义器
+ remoteChat.SetRequestCustomizer(chat.customizeRequest)
+
+ return chat, nil
+}
+
+// isQwen3Model 检查是否为 Qwen3 模型
+func (c *QwenChat) isQwen3Model() bool {
+ return provider.IsQwen3Model(c.GetModelName())
+}
+
+// customizeRequest 自定义 Qwen 请求
+func (c *QwenChat) customizeRequest(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (any, bool) {
+ // 仅 Qwen3 模型需要特殊处理
+ if !c.isQwen3Model() {
+ return nil, false
+ }
+
+ // 非流式请求需要显式禁用 thinking
+ if !isStream {
+ qwenReq := QwenChatCompletionRequest{
+ ChatCompletionRequest: *req,
+ }
+ enableThinking := false
+ qwenReq.EnableThinking = &enableThinking
+ return qwenReq, true
+ }
+
+ return nil, false
+}
diff --git a/internal/models/chat/remote_api.go b/internal/models/chat/remote_api.go
index 4193f7b1..0a5fec0d 100644
--- a/internal/models/chat/remote_api.go
+++ b/internal/models/chat/remote_api.go
@@ -5,6 +5,7 @@ import (
"context"
"encoding/json"
"fmt"
+ "io"
"net/http"
"github.com/Tencent/WeKnora/internal/logger"
@@ -13,23 +14,22 @@ import (
"github.com/sashabaranov/go-openai"
)
-// RemoteAPIChat 实现了基于的聊天
+// RemoteAPIChat 实现了基于 OpenAI 兼容 API 的聊天
+// 这是一个通用实现,不包含任何 provider 特定的逻辑
type RemoteAPIChat struct {
modelName string
client *openai.Client
modelID string
baseURL string
apiKey string
- provider provider.ProviderName // Provider identifier for routing
+ provider provider.ProviderName
+
+ // requestCustomizer 允许子类自定义请求
+ // 返回自定义请求体(如果为 nil 则使用标准请求)和是否需要使用原始 HTTP 请求
+ requestCustomizer func(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (customReq any, useRawHTTP bool)
}
-// QwenChatCompletionRequest 用于 qwen 模型的自定义请求结构体
-type QwenChatCompletionRequest struct {
- openai.ChatCompletionRequest
- EnableThinking *bool `json:"enable_thinking,omitempty"` // qwen 模型专用字段
-}
-
-// NewRemoteAPIChat 调用远程API 聊天实例
+// NewRemoteAPIChat 创建远程 API 聊天实例
func NewRemoteAPIChat(chatConfig *ChatConfig) (*RemoteAPIChat, error) {
apiKey := chatConfig.APIKey
config := openai.DefaultConfig(apiKey)
@@ -37,7 +37,6 @@ func NewRemoteAPIChat(chatConfig *ChatConfig) (*RemoteAPIChat, error) {
config.BaseURL = baseURL
}
- // Detect or use configured provider
providerName := provider.ProviderName(chatConfig.Provider)
if providerName == "" {
providerName = provider.DetectProvider(chatConfig.BaseURL)
@@ -53,20 +52,23 @@ func NewRemoteAPIChat(chatConfig *ChatConfig) (*RemoteAPIChat, error) {
}, nil
}
-// convertMessages 转换消息格式为OpenAI格式
-func (c *RemoteAPIChat) convertMessages(messages []Message) []openai.ChatCompletionMessage {
+// SetRequestCustomizer 设置请求自定义器
+func (c *RemoteAPIChat) SetRequestCustomizer(customizer func(req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool) (any, bool)) {
+ c.requestCustomizer = customizer
+}
+
+// ConvertMessages 转换消息格式为 OpenAI 格式(导出供子类使用)
+func (c *RemoteAPIChat) ConvertMessages(messages []Message) []openai.ChatCompletionMessage {
openaiMessages := make([]openai.ChatCompletionMessage, 0, len(messages))
for _, msg := range messages {
openaiMsg := openai.ChatCompletionMessage{
Role: msg.Role,
}
- // 处理内容:对于 assistant 角色,内容可能为空(当有 tool_calls 时)
if msg.Content != "" {
openaiMsg.Content = msg.Content
}
- // 处理 tool calls(assistant 角色)
if len(msg.ToolCalls) > 0 {
openaiMsg.ToolCalls = make([]openai.ToolCall, 0, len(msg.ToolCalls))
for _, tc := range msg.ToolCalls {
@@ -82,7 +84,6 @@ func (c *RemoteAPIChat) convertMessages(messages []Message) []openai.ChatComplet
}
}
- // 处理 tool 角色消息(工具返回结果)
if msg.Role == "tool" {
openaiMsg.ToolCallID = msg.ToolCallID
openaiMsg.Name = msg.Name
@@ -93,44 +94,14 @@ func (c *RemoteAPIChat) convertMessages(messages []Message) []openai.ChatComplet
return openaiMessages
}
-// isQwenModel 检查是否为 qwen 模型
-func (c *RemoteAPIChat) isAliyunQwen3Model() bool {
- return c.provider == provider.ProviderAliyun && provider.IsQwen3Model(c.modelName)
-}
-
-// isDeepSeekModel 检查是否为 DeepSeek 模型
-func (c *RemoteAPIChat) isDeepSeekModel() bool {
- return provider.IsDeepSeekModel(c.modelName)
-}
-
-// buildQwenChatCompletionRequest 构建 qwen 模型的聊天请求参数
-func (c *RemoteAPIChat) buildQwenChatCompletionRequest(messages []Message,
- opts *ChatOptions, isStream bool,
-) QwenChatCompletionRequest {
- req := QwenChatCompletionRequest{
- ChatCompletionRequest: c.buildChatCompletionRequest(messages, opts, isStream),
- }
-
- // 对于 qwen 模型,在非流式调用中强制设置 enable_thinking: false
- if !isStream {
- enableThinking := false
- req.EnableThinking = &enableThinking
- }
- return req
-}
-
-// buildChatCompletionRequest 构建聊天请求参数
-func (c *RemoteAPIChat) buildChatCompletionRequest(messages []Message,
- opts *ChatOptions, isStream bool,
-) openai.ChatCompletionRequest {
+// BuildChatCompletionRequest 构建标准聊天请求参数(导出供子类使用)
+func (c *RemoteAPIChat) BuildChatCompletionRequest(messages []Message, opts *ChatOptions, isStream bool) openai.ChatCompletionRequest {
req := openai.ChatCompletionRequest{
Model: c.modelName,
- Messages: c.convertMessages(messages),
+ Messages: c.ConvertMessages(messages),
Stream: isStream,
}
- thinking := false
- // 添加可选参数
if opts != nil {
if opts.Temperature > 0 {
req.Temperature = float32(opts.Temperature)
@@ -150,11 +121,8 @@ func (c *RemoteAPIChat) buildChatCompletionRequest(messages []Message,
if opts.PresencePenalty > 0 {
req.PresencePenalty = float32(opts.PresencePenalty)
}
- if opts.Thinking != nil {
- thinking = *opts.Thinking
- }
- // 处理 Tools(函数定义)
+ // 处理 Tools
if len(opts.Tools) > 0 {
req.Tools = make([]openai.Tool, 0, len(opts.Tools))
for _, tool := range opts.Tools {
@@ -166,39 +134,24 @@ func (c *RemoteAPIChat) buildChatCompletionRequest(messages []Message,
Description: tool.Function.Description,
},
}
- // 转换 Parameters (map[string]interface{} -> JSON Schema)
if tool.Function.Parameters != nil {
- // Parameters 已经是 JSON Schema 格式的 map,直接使用
openaiTool.Function.Parameters = tool.Function.Parameters
}
req.Tools = append(req.Tools, openaiTool)
}
}
- // 处理 ToolChoice
- // ToolChoice 可以是字符串或 ToolChoice 对象
- // 对于 "auto", "none", "required" 直接使用字符串
- // 对于特定工具名称,使用 ToolChoice 对象
- // 注意:某些模型(如 DeepSeek)不支持 tool_choice,需要跳过设置
+ // 处理 ToolChoice(标准实现)
if opts.ToolChoice != "" {
- // DeepSeek 模型不支持 tool_choice,跳过设置(默认行为会自动使用工具)
- if c.isDeepSeekModel() {
- // 对于 DeepSeek,不设置 tool_choice,让 API 使用默认行为
- // 如果有 tools,DeepSeek 会自动使用
- logger.Infof(context.Background(), "deepseek model, skip tool_choice")
- } else {
- switch opts.ToolChoice {
- case "none", "required", "auto":
- // 直接使用字符串
- req.ToolChoice = opts.ToolChoice
- default:
- // 特定工具名称,使用 ToolChoice 对象
- req.ToolChoice = openai.ToolChoice{
- Type: "function",
- Function: openai.ToolFunction{
- Name: opts.ToolChoice,
- },
- }
+ switch opts.ToolChoice {
+ case "none", "required", "auto":
+ req.ToolChoice = opts.ToolChoice
+ default:
+ req.ToolChoice = openai.ToolChoice{
+ Type: "function",
+ Function: openai.ToolFunction{
+ Name: opts.ToolChoice,
+ },
}
}
}
@@ -211,50 +164,80 @@ func (c *RemoteAPIChat) buildChatCompletionRequest(messages []Message,
}
}
- // ChatTemplateKwargs is only supported by custom backends like vLLM.
- // Official APIs (OpenAI, Aliyun, Zhipu, etc.) do not support this parameter
- // and will return 400 Bad Request if it's included.
- if c.provider == provider.ProviderGeneric {
- req.ChatTemplateKwargs = map[string]interface{}{
- "enable_thinking": thinking,
- }
- }
-
- // Log LLM request for debugging
- if jsonData, err := json.MarshalIndent(req, "", " "); err == nil {
- logger.Infof(context.Background(), "[LLM Request] model=%s, stream=%v, request:\n%s", c.modelName, isStream, string(jsonData))
- }
-
- // Log tools/functions separately for clarity
- if len(req.Tools) > 0 {
- toolNames := make([]string, 0, len(req.Tools))
- for _, tool := range req.Tools {
- toolNames = append(toolNames, tool.Function.Name)
- }
- logger.Infof(context.Background(), "[LLM Request] tools_count=%d, tool_names=%v", len(req.Tools), toolNames)
- }
-
return req
}
+// logRequest 记录请求日志
+func (c *RemoteAPIChat) logRequest(ctx context.Context, req any, isStream bool) {
+ if jsonData, err := json.MarshalIndent(req, "", " "); err == nil {
+ logger.Infof(ctx, "[LLM Request] model=%s, stream=%v, request:\n%s", c.modelName, isStream, string(jsonData))
+ }
+}
+
// Chat 进行非流式聊天
func (c *RemoteAPIChat) Chat(ctx context.Context, messages []Message, opts *ChatOptions) (*types.ChatResponse, error) {
- // 如果是 qwen 模型,使用自定义请求
- if c.isAliyunQwen3Model() {
- return c.chatWithQwen(ctx, messages, opts)
+ req := c.BuildChatCompletionRequest(messages, opts, false)
+
+ // 检查是否需要自定义请求
+ if c.requestCustomizer != nil {
+ customReq, useRawHTTP := c.requestCustomizer(&req, opts, false)
+ if useRawHTTP && customReq != nil {
+ return c.chatWithRawHTTP(ctx, customReq)
+ }
}
- // 构建请求参数
- req := c.buildChatCompletionRequest(messages, opts, false)
+ c.logRequest(ctx, req, false)
- // 发送请求
resp, err := c.client.CreateChatCompletion(ctx, req)
if err != nil {
return nil, fmt.Errorf("create chat completion: %w", err)
}
+ return c.parseCompletionResponse(&resp)
+}
+
+// chatWithRawHTTP 使用原始 HTTP 请求进行聊天(供自定义请求使用)
+func (c *RemoteAPIChat) chatWithRawHTTP(ctx context.Context, customReq any) (*types.ChatResponse, error) {
+ jsonData, err := json.Marshal(customReq)
+ if err != nil {
+ return nil, fmt.Errorf("marshal request: %w", err)
+ }
+
+ logger.Infof(ctx, "[LLM Request] model=%s, raw HTTP request:\n%s", c.modelName, string(jsonData))
+
+ endpoint := c.baseURL + "/chat/completions"
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(jsonData))
+ if err != nil {
+ return nil, fmt.Errorf("create request: %w", err)
+ }
+
+ httpReq.Header.Set("Content-Type", "application/json")
+ httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
+
+ client := &http.Client{}
+ resp, err := client.Do(httpReq)
+ if err != nil {
+ return nil, fmt.Errorf("send request: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
+ }
+
+ var chatResp openai.ChatCompletionResponse
+ if err := json.NewDecoder(resp.Body).Decode(&chatResp); err != nil {
+ return nil, fmt.Errorf("decode response: %w", err)
+ }
+
+ return c.parseCompletionResponse(&chatResp)
+}
+
+// parseCompletionResponse 解析非流式响应
+func (c *RemoteAPIChat) parseCompletionResponse(resp *openai.ChatCompletionResponse) (*types.ChatResponse, error) {
if len(resp.Choices) == 0 {
- return nil, fmt.Errorf("no response from OpenAI")
+ return nil, fmt.Errorf("no response from API")
}
choice := resp.Choices[0]
@@ -272,91 +255,6 @@ func (c *RemoteAPIChat) Chat(ctx context.Context, messages []Message, opts *Chat
},
}
- // 转换 Tool Calls
- if len(choice.Message.ToolCalls) > 0 {
- response.ToolCalls = make([]types.LLMToolCall, 0, len(choice.Message.ToolCalls))
- for _, tc := range choice.Message.ToolCalls {
- response.ToolCalls = append(response.ToolCalls, types.LLMToolCall{
- ID: tc.ID,
- Type: string(tc.Type),
- Function: types.FunctionCall{
- Name: tc.Function.Name,
- Arguments: tc.Function.Arguments,
- },
- })
- }
- }
-
- return response, nil
-}
-
-// chatWithQwen 使用自定义请求处理 qwen 模型
-func (c *RemoteAPIChat) chatWithQwen(
- ctx context.Context,
- messages []Message,
- opts *ChatOptions,
-) (*types.ChatResponse, error) {
- // 构建 qwen 请求参数
- req := c.buildQwenChatCompletionRequest(messages, opts, false)
-
- // 序列化请求
- jsonData, err := json.Marshal(req)
- if err != nil {
- return nil, fmt.Errorf("marshal request: %w", err)
- }
-
- // 构建 URL
- endpoint := c.baseURL + "/chat/completions"
-
- // 创建 HTTP 请求
- httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(jsonData))
- if err != nil {
- return nil, fmt.Errorf("create request: %w", err)
- }
-
- // 设置请求头
- httpReq.Header.Set("Content-Type", "application/json")
- httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
-
- // 发送请求
- client := &http.Client{}
- resp, err := client.Do(httpReq)
- if err != nil {
- return nil, fmt.Errorf("send request: %w", err)
- }
- defer resp.Body.Close()
-
- // 检查响应状态
- if resp.StatusCode != http.StatusOK {
- return nil, fmt.Errorf("API request failed with status: %d", resp.StatusCode)
- }
-
- // 解析响应
- var chatResp openai.ChatCompletionResponse
- if err := json.NewDecoder(resp.Body).Decode(&chatResp); err != nil {
- return nil, fmt.Errorf("decode response: %w", err)
- }
-
- if len(chatResp.Choices) == 0 {
- return nil, fmt.Errorf("no response from API")
- }
-
- choice := chatResp.Choices[0]
- response := &types.ChatResponse{
- Content: choice.Message.Content,
- FinishReason: string(choice.FinishReason),
- Usage: struct {
- PromptTokens int `json:"prompt_tokens"`
- CompletionTokens int `json:"completion_tokens"`
- TotalTokens int `json:"total_tokens"`
- }{
- PromptTokens: chatResp.Usage.PromptTokens,
- CompletionTokens: chatResp.Usage.CompletionTokens,
- TotalTokens: chatResp.Usage.TotalTokens,
- },
- }
-
- // 转换 Tool Calls
if len(choice.Message.ToolCalls) > 0 {
response.ToolCalls = make([]types.LLMToolCall, 0, len(choice.Message.ToolCalls))
for _, tc := range choice.Message.ToolCalls {
@@ -375,162 +273,295 @@ func (c *RemoteAPIChat) chatWithQwen(
}
// ChatStream 进行流式聊天
-func (c *RemoteAPIChat) ChatStream(ctx context.Context,
- messages []Message, opts *ChatOptions,
-) (<-chan types.StreamResponse, error) {
- // 构建请求参数
- req := c.buildChatCompletionRequest(messages, opts, true)
+func (c *RemoteAPIChat) ChatStream(ctx context.Context, messages []Message, opts *ChatOptions) (<-chan types.StreamResponse, error) {
+ req := c.BuildChatCompletionRequest(messages, opts, true)
+
+ // 检查是否需要自定义请求
+ if c.requestCustomizer != nil {
+ customReq, useRawHTTP := c.requestCustomizer(&req, opts, true)
+ if useRawHTTP && customReq != nil {
+ return c.chatStreamWithRawHTTP(ctx, customReq)
+ }
+ }
+
+ c.logRequest(ctx, req, true)
- // 创建流式响应通道
streamChan := make(chan types.StreamResponse)
- // 启动流式请求
stream, err := c.client.CreateChatCompletionStream(ctx, req)
if err != nil {
close(streamChan)
return nil, fmt.Errorf("create chat completion stream: %w", err)
}
- // 在后台处理流式响应
- go func() {
- defer close(streamChan)
- defer stream.Close()
-
- toolCallMap := make(map[int]*types.LLMToolCall)
- lastFunctionName := make(map[int]string)
- nameNotified := make(map[int]bool)
-
- buildOrderedToolCalls := func() []types.LLMToolCall {
- if len(toolCallMap) == 0 {
- return nil
- }
- result := make([]types.LLMToolCall, 0, len(toolCallMap))
- for i := 0; i < len(toolCallMap); i++ {
- if tc, ok := toolCallMap[i]; ok && tc != nil {
- result = append(result, *tc)
- }
- }
- if len(result) == 0 {
- return nil
- }
- return result
- }
-
- for {
- response, err := stream.Recv()
- if err != nil {
- // Check if it's a normal end of stream (io.EOF)
- if err.Error() == "EOF" {
- // Normal end of stream, send final response with collected tool calls
- streamChan <- types.StreamResponse{
- ResponseType: types.ResponseTypeAnswer,
- Content: "",
- Done: true,
- ToolCalls: buildOrderedToolCalls(),
- }
- } else {
- // Actual error, send error response
- streamChan <- types.StreamResponse{
- ResponseType: types.ResponseTypeError,
- Content: err.Error(),
- Done: true,
- }
- }
- return
- }
-
- if len(response.Choices) > 0 {
- delta := response.Choices[0].Delta
- isDone := string(response.Choices[0].FinishReason) != ""
-
- // 收集 tool calls(流式响应中 tool calls 可能分多次返回)
- if len(delta.ToolCalls) > 0 {
- for _, tc := range delta.ToolCalls {
- // 检查是否已经存在该 tool call(通过 index)
- var toolCallIndex int
- if tc.Index != nil {
- toolCallIndex = *tc.Index
- }
- toolCallEntry, exists := toolCallMap[toolCallIndex]
- if !exists || toolCallEntry == nil {
- toolCallEntry = &types.LLMToolCall{
- Type: string(tc.Type),
- Function: types.FunctionCall{
- Name: "",
- Arguments: "",
- },
- }
- toolCallMap[toolCallIndex] = toolCallEntry
- }
-
- // 更新 ID、类型
- if tc.ID != "" {
- toolCallEntry.ID = tc.ID
- }
- if tc.Type != "" {
- toolCallEntry.Type = string(tc.Type)
- }
-
- // 累积函数名称(可能分多次返回)
- if tc.Function.Name != "" {
- toolCallEntry.Function.Name += tc.Function.Name
- }
-
- // 累积参数(可能为部分 JSON)
- argsUpdated := false
- if tc.Function.Arguments != "" {
- toolCallEntry.Function.Arguments += tc.Function.Arguments
- argsUpdated = true
- }
-
- currName := toolCallEntry.Function.Name
- if currName != "" &&
- currName == lastFunctionName[toolCallIndex] &&
- argsUpdated &&
- !nameNotified[toolCallIndex] &&
- toolCallEntry.ID != "" {
- streamChan <- types.StreamResponse{
- ResponseType: types.ResponseTypeToolCall,
- Content: "",
- Done: false,
- Data: map[string]interface{}{
- "tool_name": currName,
- "tool_call_id": toolCallEntry.ID,
- },
- }
- nameNotified[toolCallIndex] = true
- }
-
- lastFunctionName[toolCallIndex] = currName
- }
- }
-
- // 发送内容块
- if delta.Content != "" {
- streamChan <- types.StreamResponse{
- ResponseType: types.ResponseTypeAnswer,
- Content: delta.Content,
- Done: isDone,
- ToolCalls: buildOrderedToolCalls(),
- }
- }
-
- // 如果是最后一次响应,确保发送包含所有 tool calls 的响应
- if isDone && len(toolCallMap) > 0 {
- streamChan <- types.StreamResponse{
- ResponseType: types.ResponseTypeAnswer,
- Content: "",
- Done: true,
- ToolCalls: buildOrderedToolCalls(),
- }
- }
- }
- }
- }()
+ go c.processStream(ctx, stream, streamChan)
return streamChan, nil
}
+// chatStreamWithRawHTTP 使用原始 HTTP 请求进行流式聊天
+func (c *RemoteAPIChat) chatStreamWithRawHTTP(ctx context.Context, customReq any) (<-chan types.StreamResponse, error) {
+ jsonData, err := json.Marshal(customReq)
+ if err != nil {
+ return nil, fmt.Errorf("marshal request: %w", err)
+ }
+
+ logger.Infof(ctx, "[LLM Stream] model=%s, raw HTTP request:\n%s", c.modelName, string(jsonData))
+
+ endpoint := c.baseURL + "/chat/completions"
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(jsonData))
+ if err != nil {
+ return nil, fmt.Errorf("create request: %w", err)
+ }
+
+ httpReq.Header.Set("Content-Type", "application/json")
+ httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
+ httpReq.Header.Set("Accept", "text/event-stream")
+
+ client := &http.Client{}
+ resp, err := client.Do(httpReq)
+ if err != nil {
+ return nil, fmt.Errorf("send request: %w", err)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ resp.Body.Close()
+ return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
+ }
+
+ streamChan := make(chan types.StreamResponse)
+
+ go c.processRawHTTPStream(ctx, resp, streamChan)
+
+ return streamChan, nil
+}
+
+// processStream 处理 OpenAI SDK 流式响应
+func (c *RemoteAPIChat) processStream(ctx context.Context, stream *openai.ChatCompletionStream, streamChan chan types.StreamResponse) {
+ defer close(streamChan)
+ defer stream.Close()
+
+ state := newStreamState()
+
+ for {
+ response, err := stream.Recv()
+ if err != nil {
+ if err.Error() == "EOF" {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ ToolCalls: state.buildOrderedToolCalls(),
+ }
+ } else {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeError,
+ Content: err.Error(),
+ Done: true,
+ }
+ }
+ return
+ }
+
+ if len(response.Choices) > 0 {
+ c.processStreamDelta(ctx, &response.Choices[0], state, streamChan)
+ }
+ }
+}
+
+// processRawHTTPStream 处理原始 HTTP 流式响应
+func (c *RemoteAPIChat) processRawHTTPStream(ctx context.Context, resp *http.Response, streamChan chan types.StreamResponse) {
+ defer close(streamChan)
+ defer resp.Body.Close()
+
+ state := newStreamState()
+ reader := NewSSEReader(resp.Body)
+
+ for {
+ event, err := reader.ReadEvent()
+ if err != nil {
+ if err.Error() != "EOF" {
+ logger.Errorf(ctx, "Stream read error: %v", err)
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeError,
+ Content: err.Error(),
+ Done: true,
+ }
+ }
+ return
+ }
+
+ if event == nil {
+ continue
+ }
+
+ if event.Done {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ ToolCalls: state.buildOrderedToolCalls(),
+ }
+ return
+ }
+
+ if event.Data == nil {
+ continue
+ }
+
+ var streamResp openai.ChatCompletionStreamResponse
+ if err := json.Unmarshal(event.Data, &streamResp); err != nil {
+ logger.Errorf(ctx, "Failed to parse stream response: %v", err)
+ continue
+ }
+
+ if len(streamResp.Choices) > 0 {
+ c.processStreamDelta(ctx, &streamResp.Choices[0], state, streamChan)
+ }
+ }
+}
+
+// streamState 流式处理状态
+type streamState struct {
+ toolCallMap map[int]*types.LLMToolCall
+ lastFunctionName map[int]string
+ nameNotified map[int]bool
+ hasThinking bool
+}
+
+func newStreamState() *streamState {
+ return &streamState{
+ toolCallMap: make(map[int]*types.LLMToolCall),
+ lastFunctionName: make(map[int]string),
+ nameNotified: make(map[int]bool),
+ hasThinking: false,
+ }
+}
+
+func (s *streamState) buildOrderedToolCalls() []types.LLMToolCall {
+ if len(s.toolCallMap) == 0 {
+ return nil
+ }
+ result := make([]types.LLMToolCall, 0, len(s.toolCallMap))
+ for i := 0; i < len(s.toolCallMap); i++ {
+ if tc, ok := s.toolCallMap[i]; ok && tc != nil {
+ result = append(result, *tc)
+ }
+ }
+ if len(result) == 0 {
+ return nil
+ }
+ return result
+}
+
+// processStreamDelta 处理流式响应的单个 delta
+func (c *RemoteAPIChat) processStreamDelta(ctx context.Context, choice *openai.ChatCompletionStreamChoice, state *streamState, streamChan chan types.StreamResponse) {
+ delta := choice.Delta
+ isDone := string(choice.FinishReason) != ""
+
+ // 处理 tool calls
+ if len(delta.ToolCalls) > 0 {
+ c.processToolCallsDelta(delta.ToolCalls, state, streamChan)
+ }
+
+ // 发送思考内容(ReasoningContent,支持 DeepSeek 等模型)
+ if delta.ReasoningContent != "" {
+ state.hasThinking = true
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeThinking,
+ Content: delta.ReasoningContent,
+ Done: false,
+ }
+ }
+
+ // 发送回答内容
+ if delta.Content != "" {
+ // If we had thinking content and this is the first answer chunk,
+ // send a thinking done event first
+ if state.hasThinking {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeThinking,
+ Content: "",
+ Done: true,
+ }
+ state.hasThinking = false // Only send once
+ }
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeAnswer,
+ Content: delta.Content,
+ Done: isDone,
+ ToolCalls: state.buildOrderedToolCalls(),
+ }
+ }
+
+ if isDone && len(state.toolCallMap) > 0 {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ ToolCalls: state.buildOrderedToolCalls(),
+ }
+ }
+}
+
+// processToolCallsDelta 处理 tool calls 的增量更新
+func (c *RemoteAPIChat) processToolCallsDelta(toolCalls []openai.ToolCall, state *streamState, streamChan chan types.StreamResponse) {
+ for _, tc := range toolCalls {
+ var toolCallIndex int
+ if tc.Index != nil {
+ toolCallIndex = *tc.Index
+ }
+ toolCallEntry, exists := state.toolCallMap[toolCallIndex]
+ if !exists || toolCallEntry == nil {
+ toolCallEntry = &types.LLMToolCall{
+ Type: string(tc.Type),
+ Function: types.FunctionCall{
+ Name: "",
+ Arguments: "",
+ },
+ }
+ state.toolCallMap[toolCallIndex] = toolCallEntry
+ }
+
+ if tc.ID != "" {
+ toolCallEntry.ID = tc.ID
+ }
+ if tc.Type != "" {
+ toolCallEntry.Type = string(tc.Type)
+ }
+ if tc.Function.Name != "" {
+ toolCallEntry.Function.Name += tc.Function.Name
+ }
+
+ argsUpdated := false
+ if tc.Function.Arguments != "" {
+ toolCallEntry.Function.Arguments += tc.Function.Arguments
+ argsUpdated = true
+ }
+
+ currName := toolCallEntry.Function.Name
+ if currName != "" &&
+ currName == state.lastFunctionName[toolCallIndex] &&
+ argsUpdated &&
+ !state.nameNotified[toolCallIndex] &&
+ toolCallEntry.ID != "" {
+ streamChan <- types.StreamResponse{
+ ResponseType: types.ResponseTypeToolCall,
+ Content: "",
+ Done: false,
+ Data: map[string]interface{}{
+ "tool_name": currName,
+ "tool_call_id": toolCallEntry.ID,
+ },
+ }
+ state.nameNotified[toolCallIndex] = true
+ }
+
+ state.lastFunctionName[toolCallIndex] = currName
+ }
+}
+
// GetModelName 获取模型名称
func (c *RemoteAPIChat) GetModelName() string {
return c.modelName
@@ -540,3 +571,18 @@ func (c *RemoteAPIChat) GetModelName() string {
func (c *RemoteAPIChat) GetModelID() string {
return c.modelID
}
+
+// GetProvider 获取 provider 名称
+func (c *RemoteAPIChat) GetProvider() provider.ProviderName {
+ return c.provider
+}
+
+// GetBaseURL 获取 baseURL
+func (c *RemoteAPIChat) GetBaseURL() string {
+ return c.baseURL
+}
+
+// GetAPIKey 获取 apiKey
+func (c *RemoteAPIChat) GetAPIKey() string {
+ return c.apiKey
+}
diff --git a/internal/models/chat/sse_reader.go b/internal/models/chat/sse_reader.go
new file mode 100644
index 00000000..45c6cf2b
--- /dev/null
+++ b/internal/models/chat/sse_reader.go
@@ -0,0 +1,59 @@
+package chat
+
+import (
+ "bufio"
+ "errors"
+ "io"
+ "strings"
+)
+
+// SSEEvent 表示一个 Server-Sent Events 事件
+type SSEEvent struct {
+ Data []byte
+ Done bool
+}
+
+// SSEReader 用于读取 SSE 流
+type SSEReader struct {
+ scanner *bufio.Scanner
+}
+
+// NewSSEReader 创建 SSE 读取器
+func NewSSEReader(reader io.Reader) *SSEReader {
+ scanner := bufio.NewScanner(reader)
+ // 设置更大的缓冲区以处理长行(思维链内容可能很长)
+ buf := make([]byte, 1024*1024)
+ scanner.Buffer(buf, 1024*1024)
+ return &SSEReader{scanner: scanner}
+}
+
+// ReadEvent 读取下一个 SSE 事件
+func (r *SSEReader) ReadEvent() (*SSEEvent, error) {
+ for r.scanner.Scan() {
+ line := r.scanner.Text()
+
+ // 空行,跳过
+ if line == "" {
+ continue
+ }
+
+ // 检查是否为结束标记
+ if line == "data: [DONE]" {
+ return &SSEEvent{Done: true}, nil
+ }
+
+ // 解析 data 行
+ if strings.HasPrefix(line, "data: ") {
+ jsonStr := line[6:]
+ return &SSEEvent{Data: []byte(jsonStr)}, nil
+ }
+
+ // 其他行(如 event:, id: 等)跳过
+ }
+
+ if err := r.scanner.Err(); err != nil {
+ return nil, err
+ }
+
+ return nil, errors.New("EOF")
+}
diff --git a/internal/models/provider/lkeap.go b/internal/models/provider/lkeap.go
new file mode 100644
index 00000000..a3c6f963
--- /dev/null
+++ b/internal/models/provider/lkeap.go
@@ -0,0 +1,65 @@
+package provider
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/Tencent/WeKnora/internal/types"
+)
+
+const (
+ // LKEAPBaseURL 腾讯云知识引擎原子能力 (LKEAP) 兼容 OpenAI 协议的 BaseURL
+ LKEAPBaseURL = "https://api.lkeap.cloud.tencent.com/v1"
+)
+
+// LKEAPProvider 实现腾讯云 LKEAP 的 Provider 接口
+// 支持 DeepSeek-R1, DeepSeek-V3 系列模型,具备思维链能力
+type LKEAPProvider struct{}
+
+func init() {
+ Register(&LKEAPProvider{})
+}
+
+// Info 返回 LKEAP provider 的元数据
+func (p *LKEAPProvider) Info() ProviderInfo {
+ return ProviderInfo{
+ Name: ProviderLKEAP,
+ DisplayName: "腾讯云 LKEAP",
+ Description: "DeepSeek-R1, DeepSeek-V3 系列模型,支持思维链",
+ DefaultURLs: map[types.ModelType]string{
+ types.ModelTypeKnowledgeQA: LKEAPBaseURL,
+ },
+ ModelTypes: []types.ModelType{
+ types.ModelTypeKnowledgeQA,
+ },
+ RequiresAuth: true,
+ }
+}
+
+// ValidateConfig 验证 LKEAP provider 配置
+func (p *LKEAPProvider) ValidateConfig(config *Config) error {
+ if config.APIKey == "" {
+ return fmt.Errorf("API key is required for LKEAP provider")
+ }
+ if config.ModelName == "" {
+ return fmt.Errorf("model name is required")
+ }
+ return nil
+}
+
+// IsLKEAPDeepSeekV3Model 检查是否为 DeepSeek V3.x 系列模型
+// V3.x 系列支持通过 Thinking 参数控制思维链开关
+func IsLKEAPDeepSeekV3Model(modelName string) bool {
+ return strings.Contains(strings.ToLower(modelName), "deepseek-v3")
+}
+
+// IsLKEAPDeepSeekR1Model 检查是否为 DeepSeek R1 系列模型
+// R1 系列默认开启思维链
+func IsLKEAPDeepSeekR1Model(modelName string) bool {
+ return strings.Contains(strings.ToLower(modelName), "deepseek-r1")
+}
+
+// IsLKEAPThinkingModel 检查是否为支持思维链的 LKEAP 模型
+func IsLKEAPThinkingModel(modelName string) bool {
+ return IsLKEAPDeepSeekR1Model(modelName) || IsLKEAPDeepSeekV3Model(modelName)
+}
diff --git a/internal/models/provider/provider.go b/internal/models/provider/provider.go
index 9742ac07..aabfb8f6 100644
--- a/internal/models/provider/provider.go
+++ b/internal/models/provider/provider.go
@@ -51,6 +51,8 @@ const (
ProviderQiniu ProviderName = "qiniu"
// 美团 LongCat AI
ProviderLongCat ProviderName = "longcat"
+ // 腾讯云 LKEAP (知识引擎原子能力)
+ ProviderLKEAP ProviderName = "lkeap"
)
// AllProviders 返回所有注册的提供者名称
@@ -74,6 +76,7 @@ func AllProviders() []ProviderName {
ProviderJina,
ProviderMimo,
ProviderLongCat,
+ ProviderLKEAP,
ProviderGPUStack,
}
}
@@ -238,6 +241,8 @@ func DetectProvider(baseURL string) ProviderName {
return ProviderQianfan
case containsAny(baseURL, "longcat.chat"):
return ProviderLongCat
+ case containsAny(baseURL, "lkeap.cloud.tencent.com", "api.lkeap"):
+ return ProviderLKEAP
default:
return ProviderGeneric
}
diff --git a/internal/types/agent.go b/internal/types/agent.go
index 203559f8..459cf75e 100644
--- a/internal/types/agent.go
+++ b/internal/types/agent.go
@@ -29,6 +29,8 @@ type AgentConfig struct {
// MCP service selection
MCPSelectionMode string `json:"mcp_selection_mode"` // MCP selection mode: "all", "selected", "none"
MCPServices []string `json:"mcp_services"` // Selected MCP service IDs (when mode is "selected")
+ // Whether to enable thinking mode (for models that support extended thinking)
+ Thinking *bool `json:"thinking"`
}
// SessionAgentConfig represents session-level agent configuration
diff --git a/internal/types/custom_agent.go b/internal/types/custom_agent.go
index a74b739f..0d700a50 100644
--- a/internal/types/custom_agent.go
+++ b/internal/types/custom_agent.go
@@ -79,6 +79,8 @@ type CustomAgentConfig struct {
Temperature float64 `yaml:"temperature" json:"temperature"`
// Maximum completion tokens (only for normal mode)
MaxCompletionTokens int `yaml:"max_completion_tokens" json:"max_completion_tokens"`
+ // Whether to enable thinking mode (for models that support extended thinking)
+ Thinking *bool `yaml:"thinking" json:"thinking"`
// ===== Agent Mode Settings =====
// Maximum iterations for ReAct loop (only for agent type)