refactor: Implement event-driven streaming and enhance session management
- Removed the StreamEvent accumulation logic, transitioning to an append-only model for event streaming. - Updated StreamManager interface to support appending events and retrieving events with offsets. - Enhanced session handling to support real-time event emission through an EventBus, improving responsiveness. - Refactored chat pipeline components to utilize the new event-driven architecture, ensuring seamless integration of agent responses and knowledge references. - Improved frontend components to handle the new event structure, ensuring accurate rendering of agent interactions and responses.
This commit is contained in:
@@ -1,405 +0,0 @@
|
||||
# Stream Manager 重构:从内容累积到事件流
|
||||
|
||||
## 问题分析
|
||||
|
||||
用户指出了一个关键问题:当前只有 `handleFinalAnswer` 在更新 stream,但其他事件(thinking、tool_call、tool_result 等)也应该推送到 stream。这样当用户刷新页面时,可以**恢复完整的输出过程**。
|
||||
|
||||
### 之前的问题 ❌
|
||||
|
||||
```go
|
||||
// StreamInfo 只存储累积的内容
|
||||
type StreamInfo struct {
|
||||
SessionID string
|
||||
RequestID string
|
||||
Query string
|
||||
Content string // ❌ 只有累积内容,丢失了事件流
|
||||
KnowledgeReferences types.References
|
||||
LastUpdated time.Time
|
||||
IsCompleted bool
|
||||
}
|
||||
|
||||
// UpdateStream 只能追加内容
|
||||
func UpdateStream(ctx, sessionID, requestID string,
|
||||
content string, references types.References) error
|
||||
```
|
||||
|
||||
**问题:**
|
||||
1. ❌ 只保存最终内容,没有保存事件流
|
||||
2. ❌ 刷新页面后,只能看到累积的答案,看不到思考/工具调用过程
|
||||
3. ❌ 无法重现完整的 Agent 执行过程
|
||||
4. ❌ 用户体验差:刷新后丢失所有中间状态
|
||||
|
||||
## 改进方案 ✅
|
||||
|
||||
### 核心思想
|
||||
|
||||
**从存储内容到存储事件流** - 每个事件(thinking、tool_call、tool_result 等)都推送到stream,刷新时可以完整重放。
|
||||
|
||||
### 新的数据结构
|
||||
|
||||
```go
|
||||
// StreamEvent 代表一个事件
|
||||
type StreamEvent struct {
|
||||
Type types.ResponseType // 事件类型
|
||||
Content string // 事件内容
|
||||
Done bool // 是否完成
|
||||
Timestamp time.Time // 事件时间
|
||||
Data map[string]interface{} // 附加数据
|
||||
}
|
||||
|
||||
// StreamInfo 存储完整的事件流
|
||||
type StreamInfo struct {
|
||||
SessionID string
|
||||
RequestID string
|
||||
Query string
|
||||
Events []StreamEvent // ✅ 完整的事件流
|
||||
KnowledgeReferences types.References
|
||||
LastUpdated time.Time
|
||||
IsCompleted bool
|
||||
}
|
||||
```
|
||||
|
||||
### 新的接口
|
||||
|
||||
```go
|
||||
type StreamManager interface {
|
||||
// RegisterStream 注册新流
|
||||
RegisterStream(ctx, sessionID, requestID, query string) error
|
||||
|
||||
// PushEvent 推送单个事件 ✅
|
||||
PushEvent(ctx, sessionID, requestID string, event StreamEvent) error
|
||||
|
||||
// UpdateReferences 更新知识引用 ✅
|
||||
UpdateReferences(ctx, sessionID, requestID string, references types.References) error
|
||||
|
||||
// CompleteStream 完成流
|
||||
CompleteStream(ctx, sessionID, requestID string) error
|
||||
|
||||
// GetStream 获取流(用于刷新重放)✅
|
||||
GetStream(ctx, sessionID, requestID string) (*StreamInfo, error)
|
||||
}
|
||||
```
|
||||
|
||||
## 实现详情
|
||||
|
||||
### 1. AgentStreamHandler - 推送所有事件
|
||||
|
||||
#### handleThought
|
||||
|
||||
```go
|
||||
func (h *AgentStreamHandler) handleThought(...) error {
|
||||
// 1. 发送 SSE
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// 2. 推送事件到 stream(用于刷新重放)✅
|
||||
h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
Type: types.ResponseTypeThinking,
|
||||
Content: data.Content,
|
||||
Done: data.Done,
|
||||
Timestamp: time.Now(),
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
#### handleToolCall
|
||||
|
||||
```go
|
||||
func (h *AgentStreamHandler) handleToolCall(...) error {
|
||||
// 1. 发送 SSE
|
||||
h.ginContext.SSEvent("message", response)
|
||||
|
||||
// 2. 推送事件到 stream(含工具调用详情)✅
|
||||
h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
Type: types.ResponseTypeToolCall,
|
||||
Content: fmt.Sprintf("Calling tool: %s", data.ToolName),
|
||||
Timestamp: time.Now(),
|
||||
Data: map[string]interface{}{
|
||||
"tool_name": data.ToolName,
|
||||
"arguments": data.Arguments,
|
||||
},
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
#### handleToolResult
|
||||
|
||||
```go
|
||||
func (h *AgentStreamHandler) handleToolResult(...) error {
|
||||
// 1. 发送 SSE
|
||||
h.ginContext.SSEvent("message", response)
|
||||
|
||||
// 2. 推送事件到 stream(含结果详情)✅
|
||||
h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
Type: responseType,
|
||||
Content: content,
|
||||
Timestamp: time.Now(),
|
||||
Data: map[string]interface{}{
|
||||
"tool_name": data.ToolName,
|
||||
"success": data.Success,
|
||||
"output": data.Output,
|
||||
"error": data.Error,
|
||||
},
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
#### handleReflection
|
||||
|
||||
```go
|
||||
func (h *AgentStreamHandler) handleReflection(...) error {
|
||||
// 1. 发送 SSE
|
||||
h.ginContext.SSEvent("message", response)
|
||||
|
||||
// 2. 推送事件到 stream ✅
|
||||
h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
Type: "reflection",
|
||||
Content: data.Content,
|
||||
Timestamp: time.Now(),
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
#### handleFinalAnswer
|
||||
|
||||
```go
|
||||
func (h *AgentStreamHandler) handleFinalAnswer(...) error {
|
||||
// 1. 发送 SSE
|
||||
h.ginContext.SSEvent("message", response)
|
||||
|
||||
// 2. 推送事件到 stream ✅
|
||||
h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
Type: types.ResponseTypeAnswer,
|
||||
Content: data.Content,
|
||||
Done: data.Done,
|
||||
Timestamp: time.Now(),
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
### 2. 刷新重放逻辑
|
||||
|
||||
#### 之前 ❌ - 只显示累积内容
|
||||
|
||||
```go
|
||||
// 只发送累积的内容
|
||||
if streamInfo.Content != "" {
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
Content: streamInfo.Content, // ❌ 失去中间过程
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
#### 现在 ✅ - 完整重放事件流
|
||||
|
||||
```go
|
||||
// 重放所有事件
|
||||
if len(streamInfo.Events) > 0 {
|
||||
logger.Debugf(ctx, "Replaying %d existing events", len(streamInfo.Events))
|
||||
for _, evt := range streamInfo.Events {
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
})
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 3. 实时监控新事件
|
||||
|
||||
#### 之前 ❌ - 监控内容增量
|
||||
|
||||
```go
|
||||
// 计算内容差异
|
||||
if len(latestStreamInfo.Content) > len(currentContent) {
|
||||
newContent := latestStreamInfo.Content[len(currentContent):]
|
||||
contentCh <- newContent
|
||||
currentContent = latestStreamInfo.Content
|
||||
}
|
||||
```
|
||||
|
||||
#### 现在 ✅ - 监控新事件
|
||||
|
||||
```go
|
||||
// 检测新事件
|
||||
if len(latestStreamInfo.Events) > currentEventCount {
|
||||
eventIndexCh <- currentEventCount
|
||||
currentEventCount = len(latestStreamInfo.Events)
|
||||
}
|
||||
|
||||
// 发送新事件
|
||||
case startIdx := <-eventIndexCh:
|
||||
for i := startIdx; i < len(latestStreamInfo.Events); i++ {
|
||||
evt := latestStreamInfo.Events[i]
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
## 数据流对比
|
||||
|
||||
### 之前 ❌
|
||||
|
||||
```
|
||||
Agent 执行
|
||||
│
|
||||
├─→ thinking event → SSE → 前端 (丢失)
|
||||
├─→ tool_call event → SSE → 前端 (丢失)
|
||||
├─→ tool_result event → SSE → 前端 (丢失)
|
||||
└─→ final_answer event → SSE → 前端
|
||||
└─→ UpdateStream(累积内容)
|
||||
|
||||
用户刷新 → GetStream → 只有累积内容 ❌
|
||||
```
|
||||
|
||||
### 现在 ✅
|
||||
|
||||
```
|
||||
Agent 执行
|
||||
│
|
||||
├─→ thinking event → SSE → 前端
|
||||
│ └─→ PushEvent(thinking) ✅
|
||||
├─→ tool_call event → SSE → 前端
|
||||
│ └─→ PushEvent(tool_call) ✅
|
||||
├─→ tool_result event → SSE → 前端
|
||||
│ └─→ PushEvent(tool_result) ✅
|
||||
└─→ final_answer event → SSE → 前端
|
||||
└─→ PushEvent(final_answer) ✅
|
||||
|
||||
用户刷新 → GetStream → 完整事件流 ✅
|
||||
→ 重放所有事件
|
||||
```
|
||||
|
||||
## 优势总结
|
||||
|
||||
| 方面 | 之前 ❌ | 现在 ✅ |
|
||||
|------|---------|---------|
|
||||
| **事件保留** | 只保留最终内容 | 保留完整事件流 |
|
||||
| **刷新体验** | 丢失中间过程 | 完整重放 |
|
||||
| **思考过程** | 不可见 | 可见 |
|
||||
| **工具调用** | 不可见 | 可见 |
|
||||
| **错误调试** | 困难 | 容易(完整历史) |
|
||||
| **用户体验** | 差 | 好 |
|
||||
|
||||
## 存储实现
|
||||
|
||||
### Memory Manager
|
||||
|
||||
```go
|
||||
type memoryStreamInfo struct {
|
||||
sessionID string
|
||||
requestID string
|
||||
query string
|
||||
events []interfaces.StreamEvent // ✅ 事件数组
|
||||
knowledgeReferences types.References
|
||||
lastUpdated time.Time
|
||||
isCompleted bool
|
||||
}
|
||||
|
||||
func (m *MemoryStreamManager) PushEvent(..., event interfaces.StreamEvent) error {
|
||||
stream.events = append(stream.events, event) // ✅ 追加事件
|
||||
stream.lastUpdated = time.Now()
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
### Redis Manager
|
||||
|
||||
```go
|
||||
type redisStreamInfo struct {
|
||||
SessionID string `json:"session_id"`
|
||||
RequestID string `json:"request_id"`
|
||||
Query string `json:"query"`
|
||||
Events []interfaces.StreamEvent `json:"events"` // ✅ 事件数组
|
||||
KnowledgeReferences types.References `json:"knowledge_references"`
|
||||
LastUpdated time.Time `json:"last_updated"`
|
||||
IsCompleted bool `json:"is_completed"`
|
||||
}
|
||||
|
||||
func (r *RedisStreamManager) PushEvent(..., event interfaces.StreamEvent) error {
|
||||
info.Events = append(info.Events, event) // ✅ 追加事件
|
||||
updatedData, _ := json.Marshal(info)
|
||||
return r.client.Set(ctx, key, updatedData, r.ttl).Err()
|
||||
}
|
||||
```
|
||||
|
||||
## 使用场景
|
||||
|
||||
### 场景 1: 正常执行
|
||||
|
||||
1. Agent 执行过程中,每个事件同时:
|
||||
- 发送 SSE 给前端(实时显示)
|
||||
- PushEvent 到 stream(持久化)
|
||||
|
||||
### 场景 2: 刷新页面
|
||||
|
||||
1. 前端重新连接
|
||||
2. GetStream 获取完整事件流
|
||||
3. 重放所有事件
|
||||
4. 继续监听新事件
|
||||
|
||||
### 场景 3: 断线重连
|
||||
|
||||
1. 客户端记录已接收的事件数量
|
||||
2. 重连后从 `Events[lastIndex:]` 开始重放
|
||||
3. 无缝恢复
|
||||
|
||||
## 前端适配
|
||||
|
||||
```typescript
|
||||
// 刷新时恢复状态
|
||||
const streamInfo = await api.getStream(sessionId, messageId);
|
||||
|
||||
// 重放所有历史事件
|
||||
streamInfo.events.forEach(event => {
|
||||
switch (event.type) {
|
||||
case 'thinking':
|
||||
showThinking(event.content);
|
||||
break;
|
||||
case 'tool_call':
|
||||
showToolCall(event.data.tool_name, event.data.arguments);
|
||||
break;
|
||||
case 'tool_result':
|
||||
showToolResult(event.data.tool_name, event.data.output);
|
||||
break;
|
||||
case 'answer':
|
||||
showAnswer(event.content);
|
||||
break;
|
||||
}
|
||||
});
|
||||
|
||||
// 继续监听新事件
|
||||
connectSSE(sessionId, messageId);
|
||||
```
|
||||
|
||||
## 性能考虑
|
||||
|
||||
### 内存占用
|
||||
|
||||
- 每个事件 ~100-500 bytes
|
||||
- 典型的 Agent 执行 ~20-50 个事件
|
||||
- 总计 ~2-25 KB per session
|
||||
- 可接受
|
||||
|
||||
### Redis 存储
|
||||
|
||||
- JSON 序列化事件数组
|
||||
- TTL 控制:默认 1 小时后自动清理
|
||||
- 压缩:Redis 自动处理
|
||||
|
||||
### 优化策略
|
||||
|
||||
1. **事件限制**: 可选地限制最大事件数(如 1000个)
|
||||
2. **压缩**: 对大量事件进行压缩
|
||||
3. **分片**: 超大事件流可以分片存储
|
||||
|
||||
---
|
||||
|
||||
**重构完成时间**: 2025-10-31
|
||||
**状态**: ✅ 完成,支持完整事件流重放
|
||||
|
||||
@@ -29,6 +29,22 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Answer Event -->
|
||||
<div v-else-if="event.type === 'answer'" class="answer-event">
|
||||
<div
|
||||
class="answer-content-wrapper"
|
||||
:class="{
|
||||
'answer-active': !event.done,
|
||||
'answer-done': event.done
|
||||
}"
|
||||
>
|
||||
<div v-if="event.content"
|
||||
class="answer-content markdown-content"
|
||||
v-html="renderMarkdown(event.content)">
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Tool Call Event -->
|
||||
<div v-else-if="event.type === 'tool_call'" class="tool-event">
|
||||
<div
|
||||
@@ -472,7 +488,7 @@ const formatJSON = (obj: any): string => {
|
||||
cursor: pointer;
|
||||
padding: 10px 14px;
|
||||
background: #ffffff;
|
||||
border: 1px solid #e5e7eb;
|
||||
border-left: 3px solid #07c05f;
|
||||
border-radius: 8px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
@@ -480,18 +496,16 @@ const formatJSON = (obj: any): string => {
|
||||
transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
|
||||
user-select: none;
|
||||
margin-bottom: 8px;
|
||||
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
|
||||
box-shadow: 0 2px 4px rgba(7, 192, 95, 0.08);
|
||||
animation: slideInDown 0.3s ease-out;
|
||||
|
||||
&:hover {
|
||||
background: #fafafa;
|
||||
border-color: #07c05f;
|
||||
background: rgba(7, 192, 95, 0.04);
|
||||
box-shadow: 0 2px 6px rgba(7, 192, 95, 0.12);
|
||||
transform: translateY(-1px);
|
||||
}
|
||||
|
||||
&:active {
|
||||
transform: translateY(0);
|
||||
background: rgba(7, 192, 95, 0.08);
|
||||
}
|
||||
|
||||
.collapse-icon {
|
||||
@@ -502,7 +516,7 @@ const formatJSON = (obj: any): string => {
|
||||
}
|
||||
|
||||
.collapse-text {
|
||||
font-size: 13px;
|
||||
font-size: 14px;
|
||||
color: #333333;
|
||||
font-weight: 500;
|
||||
letter-spacing: -0.01em;
|
||||
@@ -622,6 +636,111 @@ const formatJSON = (obj: any): string => {
|
||||
}
|
||||
}
|
||||
|
||||
// Answer Event - 类似 thinking 但有独特样式
|
||||
.answer-event {
|
||||
animation: fadeInUp 0.3s ease-out;
|
||||
|
||||
.answer-content-wrapper {
|
||||
background: #ffffff;
|
||||
border-radius: 8px;
|
||||
padding: 1px 14px;
|
||||
border-left: 3px solid #07c05f;
|
||||
box-shadow: 0 2px 4px rgba(7, 192, 95, 0.08);
|
||||
transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
|
||||
|
||||
// 进行中的 answer 显示动画
|
||||
&.answer-active {
|
||||
animation: pulseBorder 2s ease-in-out infinite;
|
||||
}
|
||||
|
||||
// 完成的 answer 保持绿色边框
|
||||
&.answer-done {
|
||||
border-left-color: #07c05f;
|
||||
}
|
||||
}
|
||||
|
||||
.answer-content {
|
||||
font-size: 14px;
|
||||
color: #333333;
|
||||
line-height: 1.6;
|
||||
|
||||
&.markdown-content {
|
||||
:deep(p) {
|
||||
margin: 8px 0;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
:deep(code) {
|
||||
background: #f0f0f0;
|
||||
padding: 2px 6px;
|
||||
border-radius: 3px;
|
||||
font-family: 'Monaco', 'Courier New', monospace;
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
:deep(pre) {
|
||||
background: #f5f5f5;
|
||||
padding: 12px;
|
||||
border-radius: 4px;
|
||||
overflow-x: auto;
|
||||
margin: 8px 0;
|
||||
|
||||
code {
|
||||
background: none;
|
||||
padding: 0;
|
||||
}
|
||||
}
|
||||
|
||||
:deep(ul), :deep(ol) {
|
||||
margin: 8px 0;
|
||||
padding-left: 24px;
|
||||
}
|
||||
|
||||
:deep(li) {
|
||||
margin: 4px 0;
|
||||
}
|
||||
|
||||
:deep(blockquote) {
|
||||
border-left: 3px solid #07c05f;
|
||||
padding-left: 12px;
|
||||
margin: 8px 0;
|
||||
color: #666;
|
||||
}
|
||||
|
||||
:deep(h1), :deep(h2), :deep(h3), :deep(h4), :deep(h5), :deep(h6) {
|
||||
margin: 12px 0 8px 0;
|
||||
font-weight: 600;
|
||||
color: #333;
|
||||
}
|
||||
|
||||
:deep(a) {
|
||||
color: #07c05f;
|
||||
text-decoration: none;
|
||||
|
||||
&:hover {
|
||||
text-decoration: underline;
|
||||
}
|
||||
}
|
||||
|
||||
:deep(table) {
|
||||
border-collapse: collapse;
|
||||
margin: 8px 0;
|
||||
font-size: 12px;
|
||||
|
||||
th, td {
|
||||
border: 1px solid #e5e7eb;
|
||||
padding: 6px 10px;
|
||||
}
|
||||
|
||||
th {
|
||||
background: #f5f5f5;
|
||||
font-weight: 600;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Tool Event
|
||||
.tool-event {
|
||||
animation: fadeInUp 0.3s ease-out;
|
||||
|
||||
@@ -5,13 +5,14 @@
|
||||
<AgentStreamDisplay :session="session" v-if="session.isAgentMode"></AgentStreamDisplay>
|
||||
<deepThink :deepSession="session" v-if="session.showThink && !session.isAgentMode"></deepThink>
|
||||
</div>
|
||||
<div ref="parentMd" v-if="!session.hideContent">
|
||||
<!-- 非 Agent 模式下才显示传统的 markdown 渲染 -->
|
||||
<div ref="parentMd" v-if="!session.hideContent && !session.isAgentMode">
|
||||
<!-- 消息正在总结中则渲染加载gif -->
|
||||
<img v-if="session.thinking" class="botanswer_laoding_gif" src="@/assets/img/botanswer_loading.gif"
|
||||
alt="正在总结答案……">
|
||||
<div v-for="(item, index) in processedMarkdown" :key="index">
|
||||
<img class="ai-markdown-img" @click="preview(item)" v-if="isLink(item)" :src="item" alt="">
|
||||
<div v-else class="ai-markdown-template" v-html="processMarkdown(item)"></div>
|
||||
<!-- 直接渲染完整内容,避免切分导致的问题,样式与 thinking 一致 -->
|
||||
<div class="content-wrapper">
|
||||
<div class="ai-markdown-template markdown-content" v-html="processMarkdown(content || session.content)"></div>
|
||||
</div>
|
||||
<div v-if="isImgLoading" class="img_loading"><t-loading size="small"></t-loading><span>加载中...</span></div>
|
||||
</div>
|
||||
@@ -61,6 +62,7 @@ const preview = (url) => {
|
||||
}
|
||||
const removeImg = () => {
|
||||
nextTick(() => {
|
||||
if (!parentMd.value) return;
|
||||
const images = parentMd.value.querySelectorAll('img.ai-markdown-img');
|
||||
if (images) {
|
||||
images.forEach(async item => {
|
||||
@@ -184,19 +186,113 @@ onMounted(async () => {
|
||||
<style lang="less" scoped>
|
||||
@import '../../../components/css/markdown.less';
|
||||
|
||||
:deep(.ai-markdown-template) {
|
||||
contain: content;
|
||||
line-height: 28px;
|
||||
letter-spacing: 1px;
|
||||
// 内容包装器 - 与 thinking 样式一致
|
||||
.content-wrapper {
|
||||
background: #ffffff;
|
||||
border-radius: 8px;
|
||||
padding: 1px 14px;
|
||||
border-left: 3px solid #07c05f;
|
||||
box-shadow: 0 2px 4px rgba(7, 192, 95, 0.08);
|
||||
transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
|
||||
animation: fadeInUp 0.3s ease-out;
|
||||
}
|
||||
|
||||
h1,
|
||||
h2,
|
||||
h3,
|
||||
h4 {
|
||||
line-height: 14px;
|
||||
font-size: 16px;
|
||||
@keyframes fadeInUp {
|
||||
from {
|
||||
opacity: 0;
|
||||
transform: translateY(8px);
|
||||
}
|
||||
to {
|
||||
opacity: 1;
|
||||
transform: translateY(0);
|
||||
}
|
||||
}
|
||||
|
||||
.ai-markdown-template {
|
||||
font-size: 14px;
|
||||
color: #333333;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
.markdown-content {
|
||||
:deep(p) {
|
||||
margin: 8px 0;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
:deep(code) {
|
||||
background: #f0f0f0;
|
||||
padding: 2px 6px;
|
||||
border-radius: 3px;
|
||||
font-family: 'Monaco', 'Courier New', monospace;
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
:deep(pre) {
|
||||
background: #f5f5f5;
|
||||
padding: 12px;
|
||||
border-radius: 4px;
|
||||
overflow-x: auto;
|
||||
margin: 8px 0;
|
||||
|
||||
code {
|
||||
background: none;
|
||||
padding: 0;
|
||||
}
|
||||
}
|
||||
|
||||
:deep(ul), :deep(ol) {
|
||||
margin: 8px 0;
|
||||
padding-left: 24px;
|
||||
}
|
||||
|
||||
:deep(li) {
|
||||
margin: 4px 0;
|
||||
}
|
||||
|
||||
:deep(blockquote) {
|
||||
border-left: 3px solid #07c05f;
|
||||
padding-left: 12px;
|
||||
margin: 8px 0;
|
||||
color: #666;
|
||||
}
|
||||
|
||||
:deep(h1), :deep(h2), :deep(h3), :deep(h4), :deep(h5), :deep(h6) {
|
||||
margin: 12px 0 8px 0;
|
||||
font-weight: 600;
|
||||
color: #333;
|
||||
}
|
||||
|
||||
:deep(a) {
|
||||
color: #07c05f;
|
||||
text-decoration: none;
|
||||
|
||||
&:hover {
|
||||
text-decoration: underline;
|
||||
}
|
||||
}
|
||||
|
||||
:deep(table) {
|
||||
border-collapse: collapse;
|
||||
margin: 8px 0;
|
||||
font-size: 12px;
|
||||
width: 100%;
|
||||
|
||||
th, td {
|
||||
border: 1px solid #e5e7eb;
|
||||
padding: 6px 10px;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
th {
|
||||
background: #f5f5f5;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
tbody tr:nth-child(even) {
|
||||
background: #fafafa;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
.ai-markdown-img {
|
||||
|
||||
@@ -60,17 +60,22 @@ const safeProcessContent = (content) => {
|
||||
flex-direction: column;
|
||||
font-size: 14px;
|
||||
width: 100%;
|
||||
border-radius: 2px;
|
||||
background-color: #30323605;
|
||||
border-radius: 8px;
|
||||
background-color: #ffffff;
|
||||
border-left: 3px solid #07c05f;
|
||||
box-shadow: 0 2px 4px rgba(7, 192, 95, 0.08);
|
||||
overflow: hidden;
|
||||
box-sizing: border-box;
|
||||
transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
|
||||
margin-bottom: 8px;
|
||||
|
||||
.refer_header {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 4px;
|
||||
color: #00000099;
|
||||
padding: 10px 14px;
|
||||
color: #333333;
|
||||
font-weight: 500;
|
||||
|
||||
.refer_title {
|
||||
display: flex;
|
||||
@@ -81,29 +86,31 @@ const safeProcessContent = (content) => {
|
||||
height: 16px;
|
||||
color: #07c05f;
|
||||
fill: currentColor;
|
||||
margin-right: 6px;
|
||||
margin-right: 8px;
|
||||
}
|
||||
|
||||
span {
|
||||
white-space: nowrap;
|
||||
font-size: 14px;
|
||||
}
|
||||
}
|
||||
|
||||
.refer_show_icon {
|
||||
font-size: 14px;
|
||||
padding: 0 2px 1px 2px;
|
||||
color: #07c05f;
|
||||
}
|
||||
}
|
||||
|
||||
.refer_header:hover {
|
||||
border-radius: 2px;
|
||||
background-color: #30323605;
|
||||
background-color: rgba(7, 192, 95, 0.04);
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.refer_box {
|
||||
padding: 2px 4px 4px 4px;
|
||||
padding: 4px 14px 10px 14px;
|
||||
flex-direction: column;
|
||||
border-top: 1px solid #f0f0f0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -119,8 +126,8 @@ const safeProcessContent = (content) => {
|
||||
}
|
||||
|
||||
.doc {
|
||||
text-decoration: underline;
|
||||
color: #366ef4;
|
||||
text-decoration: none;
|
||||
color: #07c05f;
|
||||
cursor: pointer;
|
||||
display: inline-block;
|
||||
white-space: nowrap;
|
||||
@@ -128,6 +135,14 @@ const safeProcessContent = (content) => {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
line-height: 20px;
|
||||
padding: 2px 0;
|
||||
font-weight: 500;
|
||||
transition: all 0.2s ease;
|
||||
border-bottom: 1px solid transparent;
|
||||
|
||||
&:hover {
|
||||
border-bottom-color: #07c05f;
|
||||
}
|
||||
}
|
||||
</style>
|
||||
|
||||
|
||||
@@ -110,13 +110,11 @@ const getmsgList = (data, isScrollType = false, scrollHeight) => {
|
||||
|
||||
// Reconstruct agentEventStream from agent_steps stored in database
|
||||
// This allows the frontend to restore the exact conversation state including all agent reasoning steps
|
||||
const reconstructEventStreamFromSteps = (agentSteps) => {
|
||||
if (!agentSteps || !Array.isArray(agentSteps) || agentSteps.length === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const reconstructEventStreamFromSteps = (agentSteps, messageContent) => {
|
||||
const events = [];
|
||||
|
||||
// Process agent steps if they exist
|
||||
if (agentSteps && Array.isArray(agentSteps) && agentSteps.length > 0) {
|
||||
agentSteps.forEach((step) => {
|
||||
// Add thinking event if thought content exists
|
||||
if (step.thought && step.thought.trim()) {
|
||||
@@ -148,12 +146,14 @@ const reconstructEventStreamFromSteps = (agentSteps) => {
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// 添加一个完成标记的 answer 事件,触发折叠逻辑
|
||||
if (events.length > 0) {
|
||||
// 总是添加 answer 事件如果有内容(无论是否有 agent_steps)
|
||||
// 这样可以确保最终答案始终被渲染
|
||||
if (messageContent && messageContent.trim()) {
|
||||
events.push({
|
||||
type: 'answer',
|
||||
content: '', // 空内容,因为最终答案会在 message.content 中
|
||||
content: messageContent,
|
||||
done: true
|
||||
});
|
||||
}
|
||||
@@ -174,8 +174,8 @@ const handleMsgList = async (data, isScrollType = false, newScrollHeight) => {
|
||||
if (item.agent_steps && Array.isArray(item.agent_steps) && item.agent_steps.length > 0) {
|
||||
console.log('[Message Load] Reconstructing agent steps for message:', item.id, 'steps:', item.agent_steps.length);
|
||||
item.isAgentMode = true;
|
||||
item.agentEventStream = reconstructEventStreamFromSteps(item.agent_steps);
|
||||
// 隐藏最终答案内容,用户可以通过展开步骤查看完整过程
|
||||
item.agentEventStream = reconstructEventStreamFromSteps(item.agent_steps, item.content);
|
||||
// 隐藏最终答案内容,因为它已经包含在 agentEventStream 的 answer 事件中
|
||||
item.hideContent = true;
|
||||
console.log('[Message Load] Reconstructed', item.agentEventStream.length, 'events from agent steps');
|
||||
}
|
||||
@@ -530,7 +530,10 @@ const handleAgentChunk = (data) => {
|
||||
|
||||
case 'references':
|
||||
// 知识引用
|
||||
if (data.knowledge_references) {
|
||||
if (data.data?.references) {
|
||||
message.knowledge_references = data.data.references;
|
||||
} else if (data.knowledge_references) {
|
||||
// 兼容旧格式
|
||||
message.knowledge_references = data.knowledge_references;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -3,10 +3,13 @@ package chatpipline
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/event"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// PluginChatCompletionStream implements streaming chat completion functionality
|
||||
@@ -49,7 +52,16 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
|
||||
logger.Info(ctx, "Preparing chat messages")
|
||||
chatMessages := prepareMessagesWithHistory(chatManage)
|
||||
|
||||
// Initiate streaming chat model call
|
||||
// EventBus is required for event-driven streaming
|
||||
if chatManage.EventBus == nil {
|
||||
logger.Error(ctx, "EventBus is required but not available")
|
||||
return ErrModelCall.WithError(errors.New("EventBus is required for streaming"))
|
||||
}
|
||||
eventBus := chatManage.EventBus
|
||||
|
||||
logger.Info(ctx, "EventBus detected, enabling event-driven streaming mode")
|
||||
|
||||
// Initiate streaming chat model call with independent context
|
||||
logger.Info(ctx, "Calling chat stream model")
|
||||
responseChan, err := chatModel.ChatStream(ctx, chatMessages, opt)
|
||||
if err != nil {
|
||||
@@ -62,6 +74,49 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
|
||||
}
|
||||
|
||||
logger.Info(ctx, "Chat stream initiated successfully")
|
||||
chatManage.ResponseChan = responseChan
|
||||
|
||||
// Start goroutine to consume channel and emit events directly
|
||||
go func() {
|
||||
answerID := fmt.Sprintf("%s-answer", uuid.New().String()[:8])
|
||||
var finalContent string
|
||||
|
||||
for response := range responseChan {
|
||||
// Emit event for each answer chunk
|
||||
if response.ResponseType == types.ResponseTypeAnswer {
|
||||
finalContent += response.Content
|
||||
if err := eventBus.Emit(ctx, types.Event{
|
||||
ID: answerID,
|
||||
Type: types.EventType(event.EventAgentFinalAnswer),
|
||||
SessionID: chatManage.SessionID,
|
||||
Data: event.AgentFinalAnswerData{
|
||||
Content: response.Content,
|
||||
Done: response.Done,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.Errorf(ctx, "Failed to emit answer event: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
logger.Info(ctx, "Chat stream completed, emitting completion event")
|
||||
|
||||
// Emit completion event when stream finishes
|
||||
// This allows other components to detect stream completion
|
||||
if err := eventBus.Emit(ctx, types.Event{
|
||||
ID: fmt.Sprintf("%s-complete", uuid.New().String()[:8]),
|
||||
Type: types.EventType(event.EventAgentComplete),
|
||||
SessionID: chatManage.SessionID,
|
||||
Data: event.AgentCompleteData{
|
||||
SessionID: chatManage.SessionID,
|
||||
MessageID: chatManage.MessageID,
|
||||
FinalAnswer: finalContent,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.Errorf(ctx, "Failed to emit completion event: %v", err)
|
||||
}
|
||||
|
||||
logger.Info(ctx, "Chat stream completed and completion event emitted")
|
||||
}()
|
||||
|
||||
return next()
|
||||
}
|
||||
|
||||
@@ -138,24 +138,3 @@ func (p *PluginError) WithError(err error) *PluginError {
|
||||
pp.Err = err
|
||||
return pp
|
||||
}
|
||||
|
||||
// NewFallbackChan creates a channel with a single fallback response
|
||||
func NewFallbackChan(ctx context.Context, fallbackResponse string) <-chan types.StreamResponse {
|
||||
fallabackChan := make(chan types.StreamResponse)
|
||||
go func() {
|
||||
fallabackChan <- NewFallback(ctx, fallbackResponse)
|
||||
close(fallabackChan)
|
||||
}()
|
||||
return fallabackChan
|
||||
}
|
||||
|
||||
// NewFallback creates a fallback stream response with the given content
|
||||
func NewFallback(ctx context.Context, fallbackResponse string) types.StreamResponse {
|
||||
requestID := ctx.Value(types.RequestIDContextKey).(string)
|
||||
return types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: fallbackResponse,
|
||||
Done: true,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,10 +2,14 @@ package chatpipline
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/event"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// PluginStreamFilter implements stream filtering functionality for chat pipeline
|
||||
@@ -28,57 +32,93 @@ func (p *PluginStreamFilter) OnEvent(ctx context.Context,
|
||||
eventType types.EventType, chatManage *types.ChatManage, next func() *PluginError,
|
||||
) *PluginError {
|
||||
logger.Info(ctx, "Starting stream filter")
|
||||
logger.Info(ctx, "Creating new stream channel")
|
||||
|
||||
// Create new stream channel and replace the original one
|
||||
oldStream := chatManage.ResponseChan
|
||||
newStream := make(chan types.StreamResponse)
|
||||
chatManage.ResponseChan = newStream
|
||||
// EventBus is required
|
||||
if chatManage.EventBus == nil {
|
||||
logger.Error(ctx, "EventBus is required but not available")
|
||||
return ErrModelCall.WithError(errors.New("EventBus is required for stream filtering"))
|
||||
}
|
||||
eventBus := chatManage.EventBus
|
||||
|
||||
// Initialize response builder and check if no-match prefix filtering is needed
|
||||
responseBuilder := &strings.Builder{}
|
||||
// Check if no-match prefix filtering is needed
|
||||
matchNoMatchBuilderPrefix := chatManage.SummaryConfig.NoMatchPrefix != ""
|
||||
|
||||
if matchNoMatchBuilderPrefix {
|
||||
logger.Infof(ctx, "Using no match prefix filter: %s", chatManage.SummaryConfig.NoMatchPrefix)
|
||||
// Create an event interceptor for prefix filtering
|
||||
return p.filterEventsWithPrefix(ctx, chatManage, eventBus, next)
|
||||
}
|
||||
|
||||
// Start goroutine to filter the stream
|
||||
go func() {
|
||||
logger.Info(ctx, "Starting stream filter goroutine")
|
||||
for resp := range oldStream {
|
||||
// Accumulate answer content
|
||||
if resp.ResponseType == types.ResponseTypeAnswer {
|
||||
responseBuilder.WriteString(resp.Content)
|
||||
}
|
||||
|
||||
// Skip filtering if no prefix matching is required
|
||||
if !matchNoMatchBuilderPrefix {
|
||||
newStream <- resp
|
||||
continue
|
||||
}
|
||||
|
||||
// Check if content matches the no-match prefix
|
||||
if !strings.HasPrefix(chatManage.SummaryConfig.NoMatchPrefix, responseBuilder.String()) {
|
||||
resp.Content = responseBuilder.String()
|
||||
newStream <- resp
|
||||
logger.Info(
|
||||
ctx, "Content does not match no-match prefix, passing through, content: ",
|
||||
responseBuilder.String(),
|
||||
)
|
||||
matchNoMatchBuilderPrefix = false
|
||||
}
|
||||
}
|
||||
|
||||
// Handle NO_MATCH case when stream ends
|
||||
if matchNoMatchBuilderPrefix {
|
||||
logger.Info(ctx, "Content matches no-match prefix, using fallback response")
|
||||
newStream <- NewFallback(ctx, chatManage.FallbackResponse)
|
||||
}
|
||||
logger.Info(ctx, "Stream filter completed, closing new stream")
|
||||
close(newStream)
|
||||
}()
|
||||
|
||||
logger.Info(ctx, "Stream filter initialized")
|
||||
// No filtering needed, just pass through
|
||||
logger.Info(ctx, "No prefix filtering required, passing through")
|
||||
return next()
|
||||
}
|
||||
|
||||
// filterEventsWithPrefix intercepts events, checks for NoMatchPrefix, and re-emits filtered events
|
||||
func (p *PluginStreamFilter) filterEventsWithPrefix(
|
||||
ctx context.Context,
|
||||
chatManage *types.ChatManage,
|
||||
originalEventBus types.EventBusInterface,
|
||||
next func() *PluginError,
|
||||
) *PluginError {
|
||||
logger.Info(ctx, "Setting up event-based stream filtering with NoMatchPrefix")
|
||||
|
||||
// Create a temporary EventBus to intercept events
|
||||
tempEventBus := event.NewEventBus()
|
||||
chatManage.EventBus = tempEventBus.AsEventBusInterface()
|
||||
|
||||
responseBuilder := &strings.Builder{}
|
||||
matchFound := false
|
||||
|
||||
// Subscribe to answer events from temp bus
|
||||
tempEventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.AgentFinalAnswerData)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
responseBuilder.WriteString(data.Content)
|
||||
|
||||
// Check if content does NOT match the no-match prefix (meaning it's valid content)
|
||||
if !strings.HasPrefix(chatManage.SummaryConfig.NoMatchPrefix, responseBuilder.String()) {
|
||||
logger.Infof(ctx, "Content does not match no-match prefix, emitting valid content: %s", responseBuilder.String())
|
||||
|
||||
// Emit the accumulated content as valid answer
|
||||
originalEventBus.Emit(ctx, types.Event{
|
||||
ID: evt.ID,
|
||||
Type: types.EventType(event.EventAgentFinalAnswer),
|
||||
SessionID: chatManage.SessionID,
|
||||
Data: event.AgentFinalAnswerData{
|
||||
Content: responseBuilder.String(),
|
||||
Done: data.Done,
|
||||
},
|
||||
})
|
||||
matchFound = true
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
// Call next to trigger pipeline stages that will emit to tempEventBus
|
||||
err := next()
|
||||
|
||||
// After pipeline completes, check if we need fallback
|
||||
if !matchFound && responseBuilder.Len() > 0 {
|
||||
logger.Info(ctx, "Content matches no-match prefix, emitting fallback response")
|
||||
fallbackID := fmt.Sprintf("%s-fallback", uuid.New().String()[:8])
|
||||
originalEventBus.Emit(ctx, types.Event{
|
||||
ID: fallbackID,
|
||||
Type: types.EventType(event.EventAgentFinalAnswer),
|
||||
SessionID: chatManage.SessionID,
|
||||
Data: event.AgentFinalAnswerData{
|
||||
Content: chatManage.FallbackResponse,
|
||||
Done: true,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Restore original EventBus
|
||||
chatManage.EventBus = originalEventBus
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -6,6 +6,8 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/event"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/tracing"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
@@ -187,28 +189,37 @@ func (p *PluginTracing) ChatCompletionStream(ctx context.Context,
|
||||
)
|
||||
|
||||
responseBuilder := &strings.Builder{}
|
||||
oldStream := chatManage.ResponseChan
|
||||
newStream := make(chan types.StreamResponse)
|
||||
chatManage.ResponseChan = newStream
|
||||
|
||||
go func(ctx context.Context) {
|
||||
for resp := range oldStream {
|
||||
if resp.ResponseType == types.ResponseTypeAnswer {
|
||||
responseBuilder.WriteString(resp.Content)
|
||||
// EventBus is required
|
||||
if chatManage.EventBus == nil {
|
||||
logger.Warn(ctx, "Tracing: EventBus not available, skipping metrics collection")
|
||||
return next()
|
||||
}
|
||||
eventBus := chatManage.EventBus
|
||||
|
||||
// Subscribe to events and collect metrics
|
||||
logger.Info(ctx, "Tracing: Subscribing to answer events for metrics collection")
|
||||
|
||||
eventBus.On(types.EventType(event.EventAgentFinalAnswer), func(ctx context.Context, evt types.Event) error {
|
||||
data, ok := evt.Data.(event.AgentFinalAnswerData)
|
||||
if ok {
|
||||
responseBuilder.WriteString(data.Content)
|
||||
|
||||
// If this is the final chunk, record metrics
|
||||
if data.Done {
|
||||
elapsedMS := time.Since(startTime).Milliseconds()
|
||||
span.SetAttributes(
|
||||
attribute.Bool("chat_completion_success", true),
|
||||
attribute.Int64("response_time_ms", elapsedMS),
|
||||
attribute.String("chat_response", responseBuilder.String()),
|
||||
attribute.Int("final_response_length", responseBuilder.Len()),
|
||||
attribute.Float64("tokens_per_second", float64(responseBuilder.Len())/float64(elapsedMS)*1000),
|
||||
)
|
||||
span.End()
|
||||
}
|
||||
newStream <- resp
|
||||
}
|
||||
elapsedMS := time.Since(startTime).Milliseconds()
|
||||
span.SetAttributes(
|
||||
attribute.Bool("chat_completion_success", true),
|
||||
attribute.Int64("response_time_ms", elapsedMS),
|
||||
attribute.String("chat_response", responseBuilder.String()),
|
||||
attribute.Int("final_response_length", responseBuilder.Len()),
|
||||
attribute.Float64("tokens_per_second", float64(responseBuilder.Len())/float64(elapsedMS)*1000),
|
||||
)
|
||||
span.End()
|
||||
close(newStream)
|
||||
}(ctx)
|
||||
return nil
|
||||
})
|
||||
|
||||
return next()
|
||||
}
|
||||
|
||||
@@ -15,10 +15,16 @@ import (
|
||||
"github.com/Tencent/WeKnora/internal/tracing"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/google/uuid"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
"go.opentelemetry.io/otel/codes"
|
||||
)
|
||||
|
||||
// generateEventID generates a unique event ID with type suffix for better traceability
|
||||
func generateEventID(suffix string) string {
|
||||
return fmt.Sprintf("%s-%s", uuid.New().String()[:8], suffix)
|
||||
}
|
||||
|
||||
// sessionService implements the SessionService interface for managing conversation sessions
|
||||
type sessionService struct {
|
||||
cfg *config.Config // Application configuration
|
||||
@@ -393,9 +399,8 @@ func (s *sessionService) GenerateTitleAsync(ctx context.Context, session *types.
|
||||
}
|
||||
|
||||
// KnowledgeQA performs knowledge base question answering with LLM summarization
|
||||
func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session, query string, knowledgeBaseIDs []string) (
|
||||
[]*types.SearchResult, <-chan types.StreamResponse, error,
|
||||
) {
|
||||
// Events are emitted through eventBus (references, answer chunks, completion)
|
||||
func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session, query string, knowledgeBaseIDs []string, assistantMessageID string, eventBus *event.EventBus) error {
|
||||
logger.Infof(ctx, "Knowledge base question answering parameters, session ID: %s, query: %s", session.ID, query)
|
||||
|
||||
// If no knowledge base IDs provided, fall back to session's default
|
||||
@@ -405,7 +410,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
|
||||
logger.Infof(ctx, "No knowledge base IDs provided, using session default: %s", session.KnowledgeBaseID)
|
||||
} else {
|
||||
logger.Warnf(ctx, "Session has no associated knowledge base, session ID: %s", session.ID)
|
||||
return nil, nil, errors.New("session has no knowledge base")
|
||||
return errors.New("session has no knowledge base")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -414,7 +419,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
|
||||
// Determine chat model ID: prioritize Remote models
|
||||
chatModelID, err := s.selectChatModelID(ctx, session, knowledgeBaseIDs)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
return err
|
||||
}
|
||||
|
||||
// Create chat management object with session settings
|
||||
@@ -423,6 +428,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
|
||||
Query: query,
|
||||
RewriteQuery: query,
|
||||
SessionID: session.ID,
|
||||
MessageID: assistantMessageID, // NEW: For event emission in pipeline
|
||||
KnowledgeBaseID: knowledgeBaseIDs[0], // For backward compatibility, use first KB ID
|
||||
KnowledgeBaseIDs: knowledgeBaseIDs, // Multi-KB support
|
||||
VectorThreshold: session.VectorThreshold,
|
||||
@@ -447,6 +453,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
|
||||
MaxCompletionTokens: session.SummaryParameters.MaxCompletionTokens,
|
||||
},
|
||||
FallbackResponse: session.FallbackResponse,
|
||||
EventBus: eventBus.AsEventBusInterface(), // NEW: For pipeline to emit events directly
|
||||
}
|
||||
|
||||
// Start knowledge QA event processing
|
||||
@@ -457,11 +464,31 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
|
||||
"session_id": session.ID,
|
||||
"knowledge_base_id": session.KnowledgeBaseID,
|
||||
})
|
||||
return nil, nil, err
|
||||
return err
|
||||
}
|
||||
|
||||
logger.Info(ctx, "Knowledge base question answering completed")
|
||||
return chatManage.MergeResult, chatManage.ResponseChan, nil
|
||||
// Emit references event if we have search results
|
||||
if len(chatManage.MergeResult) > 0 {
|
||||
logger.Infof(ctx, "Emitting references event with %d results", len(chatManage.MergeResult))
|
||||
if err := eventBus.Emit(ctx, event.Event{
|
||||
ID: generateEventID("references"),
|
||||
Type: event.EventAgentReferences,
|
||||
SessionID: session.ID,
|
||||
Data: event.AgentReferencesData{
|
||||
References: chatManage.MergeResult,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.Errorf(ctx, "Failed to emit references event: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Note: Answer events are now emitted directly by chat_completion_stream plugin
|
||||
// Completion event will be emitted when the last answer event has Done=true
|
||||
// We can optionally add a completion watcher here if needed, but for now
|
||||
// the frontend can detect completion from the Done flag
|
||||
|
||||
logger.Info(ctx, "Knowledge base question answering initiated")
|
||||
return nil
|
||||
}
|
||||
|
||||
// selectChatModelID selects the appropriate chat model ID with priority for Remote models
|
||||
@@ -564,28 +591,43 @@ func (s *sessionService) KnowledgeQAByEvent(ctx context.Context,
|
||||
)
|
||||
|
||||
// Process each event in sequence
|
||||
for _, event := range eventList {
|
||||
logger.Infof(ctx, "Starting to trigger event: %v", event)
|
||||
err := s.eventManager.Trigger(ctx, event, chatManage)
|
||||
for _, eventType := range eventList {
|
||||
logger.Infof(ctx, "Starting to trigger event: %v", eventType)
|
||||
err := s.eventManager.Trigger(ctx, eventType, chatManage)
|
||||
|
||||
// Handle case where search returns no results
|
||||
if err == chatpipline.ErrSearchNothing {
|
||||
logger.Warnf(ctx, "Event %v triggered, search result is empty, using fallback response", event)
|
||||
chatManage.ResponseChan = chatpipline.NewFallbackChan(ctx, chatManage.FallbackResponse)
|
||||
logger.Warnf(ctx, "Event %v triggered, search result is empty, using fallback response", eventType)
|
||||
chatManage.ChatResponse = &types.ChatResponse{Content: chatManage.FallbackResponse}
|
||||
|
||||
// Emit fallback response as answer event
|
||||
if chatManage.EventBus != nil {
|
||||
fallbackID := generateEventID("fallback")
|
||||
if err := chatManage.EventBus.Emit(ctx, types.Event{
|
||||
ID: fallbackID,
|
||||
Type: types.EventType(event.EventAgentThought),
|
||||
SessionID: chatManage.SessionID,
|
||||
Data: event.AgentThoughtData{
|
||||
Content: chatManage.FallbackResponse,
|
||||
Done: true,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.Errorf(ctx, "Failed to emit fallback answer event: %v", err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Handle other errors
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Event triggering failed, event: %v, error type: %s, description: %s, error: %v",
|
||||
event, err.ErrorType, err.Description, err.Err)
|
||||
eventType, err.ErrorType, err.Description, err.Err)
|
||||
span.RecordError(err.Err)
|
||||
span.SetStatus(codes.Error, err.Description)
|
||||
span.SetAttributes(attribute.String("error_type", err.ErrorType))
|
||||
return err.Err
|
||||
}
|
||||
logger.Infof(ctx, "Event %v triggered successfully", event)
|
||||
logger.Infof(ctx, "Event %v triggered successfully", eventType)
|
||||
}
|
||||
|
||||
logger.Info(ctx, "All events triggered successfully")
|
||||
@@ -680,9 +722,7 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
|
||||
}
|
||||
|
||||
// AgentQA performs agent-based question answering with conversation history and streaming support
|
||||
func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) (
|
||||
[]*types.SearchResult, error,
|
||||
) {
|
||||
func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) error {
|
||||
sessionID := session.ID
|
||||
tenantID := ctx.Value(types.TenantIDContextKey).(uint)
|
||||
logger.Infof(ctx, "Start agent-based question answering, session ID: %s, tenant ID: %d, query: %s", sessionID, tenantID, query)
|
||||
@@ -696,13 +736,13 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
|
||||
// Check if agent is enabled at session level
|
||||
if session.AgentConfig == nil || !session.AgentConfig.Enabled {
|
||||
logger.Warnf(ctx, "Agent not enabled for session: %s", sessionID)
|
||||
return nil, errors.New("agent not enabled for this session")
|
||||
return errors.New("agent not enabled for this session")
|
||||
}
|
||||
|
||||
// Check if tenant has agent configuration
|
||||
if tenantInfo.AgentConfig == nil {
|
||||
logger.Warnf(ctx, "Tenant %d has no agent configuration", tenantInfo.ID)
|
||||
return nil, errors.New("tenant has no agent configuration")
|
||||
return errors.New("tenant has no agent configuration")
|
||||
}
|
||||
|
||||
// Create runtime AgentConfig by merging session and tenant configs
|
||||
@@ -734,12 +774,12 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
|
||||
allKBs, err := s.knowledgeBaseService.ListKnowledgeBases(ctx)
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Failed to list knowledge bases for tenant: %v", err)
|
||||
return nil, fmt.Errorf("failed to list knowledge bases: %w", err)
|
||||
return fmt.Errorf("failed to list knowledge bases: %w", err)
|
||||
}
|
||||
|
||||
if len(allKBs) == 0 {
|
||||
logger.Warnf(ctx, "No knowledge bases available for agent session: %s", sessionID)
|
||||
return nil, errors.New("no knowledge bases available for agent")
|
||||
return errors.New("no knowledge bases available for agent")
|
||||
}
|
||||
|
||||
// Extract knowledge base IDs
|
||||
@@ -764,7 +804,7 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
|
||||
summaryModel, err := s.modelService.GetChatModel(ctx, agentConfig.ThinkingModelID)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Failed to get chat model: %v", err)
|
||||
return nil, fmt.Errorf("failed to get chat model: %w", err)
|
||||
return fmt.Errorf("failed to get chat model: %w", err)
|
||||
}
|
||||
|
||||
// Get or create contextManager for this session
|
||||
@@ -782,30 +822,27 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
|
||||
engine, err := s.agentService.CreateAgentEngine(ctx, agentConfig, eventBus, contextManager, session.ID)
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Failed to create agent engine: %v", err)
|
||||
return nil, err
|
||||
return err
|
||||
}
|
||||
|
||||
// Execute agent with streaming (asynchronously)
|
||||
// Events will be emitted to EventBus and handled by the Handler layer
|
||||
logger.Info(ctx, "Executing agent with streaming")
|
||||
go func() {
|
||||
if _, err := engine.Execute(ctx, sessionID, assistantMessageID, query, llmContext); err != nil {
|
||||
logger.Errorf(ctx, "Agent execution failed: %v", err)
|
||||
// Emit error event to the EventBus used by this agent
|
||||
eventBus.Emit(ctx, event.Event{
|
||||
Type: event.EventError,
|
||||
if _, err := engine.Execute(ctx, sessionID, assistantMessageID, query, llmContext); err != nil {
|
||||
logger.Errorf(ctx, "Agent execution failed: %v", err)
|
||||
// Emit error event to the EventBus used by this agent
|
||||
eventBus.Emit(ctx, event.Event{
|
||||
Type: event.EventError,
|
||||
SessionID: sessionID,
|
||||
Data: event.ErrorData{
|
||||
Error: err.Error(),
|
||||
Stage: "agent_execution",
|
||||
SessionID: sessionID,
|
||||
Data: event.ErrorData{
|
||||
Error: err.Error(),
|
||||
Stage: "agent_execution",
|
||||
SessionID: sessionID,
|
||||
},
|
||||
})
|
||||
}
|
||||
}()
|
||||
|
||||
},
|
||||
})
|
||||
}
|
||||
// Return empty - events will be handled by Handler via EventBus subscription
|
||||
return nil, nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// getContextManagerForSession creates a context manager for the session based on configuration
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
package event
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
)
|
||||
|
||||
// EventBusAdapter adapts *EventBus to types.EventBusInterface
|
||||
// This allows EventBus to be used through the interface without circular dependencies
|
||||
type EventBusAdapter struct {
|
||||
bus *EventBus
|
||||
}
|
||||
|
||||
// NewEventBusAdapter creates a new adapter for EventBus
|
||||
func NewEventBusAdapter(bus *EventBus) types.EventBusInterface {
|
||||
return &EventBusAdapter{bus: bus}
|
||||
}
|
||||
|
||||
// On registers an event handler for a specific event type
|
||||
func (a *EventBusAdapter) On(eventType types.EventType, handler types.EventHandler) {
|
||||
// Convert types.EventType to event.EventType
|
||||
evtType := EventType(eventType)
|
||||
|
||||
// Convert types.EventHandler to event.EventHandler
|
||||
evtHandler := func(ctx context.Context, evt Event) error {
|
||||
// Convert event.Event to types.Event
|
||||
typesEvt := types.Event{
|
||||
ID: evt.ID,
|
||||
Type: types.EventType(evt.Type),
|
||||
SessionID: evt.SessionID,
|
||||
Data: evt.Data,
|
||||
Metadata: evt.Metadata,
|
||||
RequestID: evt.RequestID,
|
||||
}
|
||||
return handler(ctx, typesEvt)
|
||||
}
|
||||
|
||||
a.bus.On(evtType, evtHandler)
|
||||
}
|
||||
|
||||
// Emit publishes an event to all registered handlers
|
||||
func (a *EventBusAdapter) Emit(ctx context.Context, evt types.Event) error {
|
||||
// Convert types.Event to event.Event
|
||||
eventEvt := Event{
|
||||
ID: evt.ID,
|
||||
Type: EventType(evt.Type),
|
||||
SessionID: evt.SessionID,
|
||||
Data: evt.Data,
|
||||
Metadata: evt.Metadata,
|
||||
RequestID: evt.RequestID,
|
||||
}
|
||||
return a.bus.Emit(ctx, eventEvt)
|
||||
}
|
||||
|
||||
// AsEventBusInterface converts *EventBus to types.EventBusInterface
|
||||
func (eb *EventBus) AsEventBusInterface() types.EventBusInterface {
|
||||
return NewEventBusAdapter(eb)
|
||||
}
|
||||
@@ -10,14 +10,13 @@ import (
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
// AgentStreamHandler handles agent events for SSE streaming
|
||||
// It uses a dedicated EventBus per request to avoid SessionID filtering
|
||||
// Events are appended to StreamManager without accumulation
|
||||
type AgentStreamHandler struct {
|
||||
ctx context.Context
|
||||
ginContext *gin.Context
|
||||
sessionID string
|
||||
assistantMessageID string
|
||||
requestID string
|
||||
@@ -27,17 +26,15 @@ type AgentStreamHandler struct {
|
||||
eventBus *event.EventBus
|
||||
|
||||
// State tracking
|
||||
knowledgeRefs []*types.SearchResult
|
||||
finalAnswer string
|
||||
accumulatedContent map[string]string // Accumulate content per event ID (thought, answer, reflection)
|
||||
eventStartTimes map[string]time.Time // Track start time for duration calculation
|
||||
mu sync.Mutex
|
||||
knowledgeRefs []*types.SearchResult
|
||||
finalAnswer string
|
||||
eventStartTimes map[string]time.Time // Track start time for duration calculation
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
// NewAgentStreamHandler creates a new handler for agent SSE streaming
|
||||
func NewAgentStreamHandler(
|
||||
ctx context.Context,
|
||||
c *gin.Context,
|
||||
sessionID, assistantMessageID, requestID string,
|
||||
assistantMessage *types.Message,
|
||||
streamManager interfaces.StreamManager,
|
||||
@@ -45,7 +42,6 @@ func NewAgentStreamHandler(
|
||||
) *AgentStreamHandler {
|
||||
return &AgentStreamHandler{
|
||||
ctx: ctx,
|
||||
ginContext: c,
|
||||
sessionID: sessionID,
|
||||
assistantMessageID: assistantMessageID,
|
||||
requestID: requestID,
|
||||
@@ -53,7 +49,6 @@ func NewAgentStreamHandler(
|
||||
streamManager: streamManager,
|
||||
eventBus: eventBus,
|
||||
knowledgeRefs: make([]*types.SearchResult, 0),
|
||||
accumulatedContent: make(map[string]string),
|
||||
eventStartTimes: make(map[string]time.Time),
|
||||
}
|
||||
}
|
||||
@@ -69,7 +64,7 @@ func (h *AgentStreamHandler) Subscribe() {
|
||||
h.eventBus.On(event.EventAgentFinalAnswer, h.handleFinalAnswer)
|
||||
h.eventBus.On(event.EventAgentReflection, h.handleReflection)
|
||||
h.eventBus.On(event.EventError, h.handleError)
|
||||
h.eventBus.On(event.EventAgentComplete, h.handleComplete)
|
||||
h.eventBus.On(event.EventSessionTitle, h.handleSessionTitle)
|
||||
}
|
||||
|
||||
// handleThought handles agent thought events
|
||||
@@ -105,23 +100,18 @@ func (h *AgentStreamHandler) handleThought(ctx context.Context, evt event.Event)
|
||||
|
||||
h.mu.Unlock()
|
||||
|
||||
// Send SSE response (real-time incremental)
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: types.ResponseTypeThinking,
|
||||
Content: data.Content,
|
||||
Done: data.Done,
|
||||
Data: metadata,
|
||||
// Append this chunk to stream (no accumulation - frontend will accumulate)
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeThinking,
|
||||
Content: data.Content, // Just this chunk
|
||||
Done: data.Done,
|
||||
Timestamp: time.Now(),
|
||||
Data: metadata,
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Append thought event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Accumulate content and replace event in stream (so refresh can see progress)
|
||||
h.mu.Lock()
|
||||
h.accumulateAndReplaceEventWithData(evt.ID, types.ResponseTypeThinking, data.Content, data.Done, metadata)
|
||||
h.mu.Unlock()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -137,20 +127,8 @@ func (h *AgentStreamHandler) handleToolCall(ctx context.Context, evt event.Event
|
||||
"arguments": data.Arguments,
|
||||
}
|
||||
|
||||
// Send SSE response
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: types.ResponseTypeToolCall,
|
||||
Content: fmt.Sprintf("Calling tool: %s", data.ToolName),
|
||||
Done: false,
|
||||
Data: metadata,
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Push event to stream for replay on refresh
|
||||
if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
// Append event to stream
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeToolCall,
|
||||
Content: fmt.Sprintf("Calling tool: %s", data.ToolName),
|
||||
@@ -158,7 +136,7 @@ func (h *AgentStreamHandler) handleToolCall(ctx context.Context, evt event.Event
|
||||
Timestamp: time.Now(),
|
||||
Data: metadata,
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Push tool call event to stream failed", "error", err)
|
||||
logger.GetLogger(h.ctx).Error("Append tool call event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
@@ -197,19 +175,8 @@ func (h *AgentStreamHandler) handleToolResult(ctx context.Context, evt event.Eve
|
||||
}
|
||||
}
|
||||
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: responseType,
|
||||
Content: content,
|
||||
Done: false,
|
||||
Data: metadata,
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Push event to stream for replay on refresh
|
||||
if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
// Append event to stream
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: responseType,
|
||||
Content: content,
|
||||
@@ -217,7 +184,7 @@ func (h *AgentStreamHandler) handleToolResult(ctx context.Context, evt event.Eve
|
||||
Timestamp: time.Now(),
|
||||
Data: metadata,
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Push tool result event to stream failed", "error", err)
|
||||
logger.GetLogger(h.ctx).Error("Append tool result event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
@@ -271,26 +238,8 @@ func (h *AgentStreamHandler) handleReferences(ctx context.Context, evt event.Eve
|
||||
// Update assistant message references
|
||||
h.assistantMessage.KnowledgeReferences = h.knowledgeRefs
|
||||
|
||||
// Send SSE response
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: types.ResponseTypeReferences,
|
||||
KnowledgeReferences: h.knowledgeRefs,
|
||||
Done: false,
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Update stream references
|
||||
if err := h.streamManager.UpdateReferences(
|
||||
h.ctx, h.sessionID, h.assistantMessageID, h.knowledgeRefs,
|
||||
); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Update stream references failed", "error", err)
|
||||
}
|
||||
|
||||
// Push event to stream for replay on refresh
|
||||
if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
// Append references event to stream
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeReferences,
|
||||
Content: "",
|
||||
@@ -300,7 +249,7 @@ func (h *AgentStreamHandler) handleReferences(ctx context.Context, evt event.Eve
|
||||
"references": h.knowledgeRefs,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Push references event to stream failed", "error", err)
|
||||
logger.GetLogger(h.ctx).Error("Append references event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
@@ -314,26 +263,21 @@ func (h *AgentStreamHandler) handleFinalAnswer(ctx context.Context, evt event.Ev
|
||||
}
|
||||
|
||||
h.mu.Lock()
|
||||
|
||||
// Accumulate final answer (this persists and won't be reset)
|
||||
// Accumulate final answer locally for assistant message (database)
|
||||
h.finalAnswer += data.Content
|
||||
h.assistantMessage.Content = h.finalAnswer
|
||||
|
||||
// Send SSE response (real-time incremental)
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: data.Content,
|
||||
Done: data.Done,
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Replace answer event in stream (so refresh can see progress)
|
||||
h.accumulateAndReplaceEvent(evt.ID, types.ResponseTypeAnswer, data.Content, data.Done)
|
||||
h.mu.Unlock()
|
||||
|
||||
// Append this chunk to stream (frontend will accumulate by event ID)
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeAnswer,
|
||||
Content: data.Content, // Just this chunk
|
||||
Done: data.Done,
|
||||
Timestamp: time.Now(),
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Append answer event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -344,22 +288,17 @@ func (h *AgentStreamHandler) handleReflection(ctx context.Context, evt event.Eve
|
||||
return nil
|
||||
}
|
||||
|
||||
// Send reflection as SSE (real-time incremental)
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: "reflection", // Special type for reflection
|
||||
Content: data.Content,
|
||||
Done: data.Done,
|
||||
// Append this chunk to stream (frontend will accumulate by event ID)
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeReflection,
|
||||
Content: data.Content, // Just this chunk
|
||||
Done: data.Done,
|
||||
Timestamp: time.Now(),
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Append reflection event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
|
||||
// Accumulate reflection per tool call and replace event in stream
|
||||
h.mu.Lock()
|
||||
h.accumulateAndReplaceEvent(evt.ID, types.ResponseTypeReflection, data.Content, data.Done)
|
||||
h.mu.Unlock()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -370,97 +309,52 @@ func (h *AgentStreamHandler) handleError(ctx context.Context, evt event.Event) e
|
||||
return nil
|
||||
}
|
||||
|
||||
response := types.StreamResponse{
|
||||
ID: h.requestID,
|
||||
ResponseType: types.ResponseTypeError,
|
||||
Content: data.Error,
|
||||
Done: true,
|
||||
// Build error metadata
|
||||
metadata := map[string]interface{}{
|
||||
"stage": data.Stage,
|
||||
"error": data.Error,
|
||||
}
|
||||
|
||||
h.ginContext.SSEvent("message", response)
|
||||
h.ginContext.Writer.Flush()
|
||||
// Append error event to stream
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeError,
|
||||
Content: data.Error,
|
||||
Done: true,
|
||||
Timestamp: time.Now(),
|
||||
Data: metadata,
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Append error event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// handleComplete handles agent complete events
|
||||
func (h *AgentStreamHandler) handleComplete(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.AgentCompleteData)
|
||||
// handleSessionTitle handles session title update events
|
||||
func (h *AgentStreamHandler) handleSessionTitle(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.SessionTitleData)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
|
||||
// Update assistant message with final data
|
||||
if data.MessageID == h.assistantMessageID {
|
||||
h.assistantMessage.Content = data.FinalAnswer
|
||||
h.assistantMessage.IsCompleted = true
|
||||
|
||||
// Update knowledge references if provided
|
||||
if len(data.KnowledgeRefs) > 0 {
|
||||
knowledgeRefs := make([]*types.SearchResult, 0, len(data.KnowledgeRefs))
|
||||
for _, ref := range data.KnowledgeRefs {
|
||||
if sr, ok := ref.(*types.SearchResult); ok {
|
||||
knowledgeRefs = append(knowledgeRefs, sr)
|
||||
}
|
||||
}
|
||||
h.assistantMessage.KnowledgeReferences = knowledgeRefs
|
||||
}
|
||||
|
||||
// Update agent steps if provided
|
||||
if data.AgentSteps != nil {
|
||||
if steps, ok := data.AgentSteps.([]types.AgentStep); ok {
|
||||
h.assistantMessage.AgentSteps = steps
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Complete stream
|
||||
if err := h.streamManager.CompleteStream(h.ctx, h.sessionID, h.assistantMessageID); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Complete stream failed", "error", err)
|
||||
// Append title event to stream
|
||||
if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evt.ID,
|
||||
Type: types.ResponseTypeSessionTitle,
|
||||
Content: data.Title,
|
||||
Done: true,
|
||||
Timestamp: time.Now(),
|
||||
Data: map[string]interface{}{
|
||||
"session_id": data.SessionID,
|
||||
"title": data.Title,
|
||||
},
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error("Append session title event to stream failed", "error", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// accumulateAndReplaceEvent accumulates content per event ID and replaces the event in stream
|
||||
// This is a common pattern for thought, answer, and reflection events
|
||||
func (h *AgentStreamHandler) accumulateAndReplaceEvent(
|
||||
evtID string,
|
||||
evtType types.ResponseType,
|
||||
content string,
|
||||
done bool,
|
||||
) {
|
||||
h.accumulateAndReplaceEventWithData(evtID, evtType, content, done, nil)
|
||||
}
|
||||
|
||||
// accumulateAndReplaceEventWithData accumulates content and replaces event with metadata
|
||||
func (h *AgentStreamHandler) accumulateAndReplaceEventWithData(
|
||||
evtID string,
|
||||
evtType types.ResponseType,
|
||||
content string,
|
||||
done bool,
|
||||
data map[string]interface{},
|
||||
) {
|
||||
h.accumulatedContent[evtID] += content
|
||||
if err := h.streamManager.ReplaceEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
|
||||
ID: evtID,
|
||||
Type: evtType,
|
||||
Content: h.accumulatedContent[evtID],
|
||||
Done: done,
|
||||
Timestamp: time.Now(),
|
||||
Data: data,
|
||||
}); err != nil {
|
||||
logger.GetLogger(h.ctx).Error(fmt.Sprintf("Replace %s event in stream failed", evtType), "error", err)
|
||||
}
|
||||
// Clean up when done
|
||||
if done {
|
||||
delete(h.accumulatedContent, evtID)
|
||||
}
|
||||
}
|
||||
|
||||
// Helper functions
|
||||
func getString(m map[string]interface{}, key string) string {
|
||||
if val, ok := m[key].(string); ok {
|
||||
|
||||
+292
-370
@@ -3,7 +3,6 @@ package handler
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
@@ -14,7 +13,6 @@ import (
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// SessionHandler handles all HTTP requests related to conversation sessions
|
||||
@@ -571,154 +569,141 @@ func (h *SessionHandler) ContinueStream(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
|
||||
// Get stream information
|
||||
streamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
|
||||
// Get initial events from stream (offset 0)
|
||||
events, currentOffset, err := h.streamManager.GetEvents(ctx, sessionID, messageID, 0)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, nil)
|
||||
c.Error(errors.NewInternalServerError(fmt.Sprintf("Failed to get stream data: %s", err.Error())))
|
||||
return
|
||||
}
|
||||
|
||||
if streamInfo == nil {
|
||||
logger.Warnf(ctx, "Active stream not found, session ID: %s, message ID: %s", sessionID, messageID)
|
||||
if len(events) == 0 {
|
||||
logger.Warnf(ctx, "No events found in stream, session ID: %s, message ID: %s", sessionID, messageID)
|
||||
c.JSON(http.StatusNotFound, gin.H{
|
||||
"success": false,
|
||||
"error": "Active stream not found",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// If stream is already completed, return the full message
|
||||
if streamInfo.IsCompleted {
|
||||
logger.Infof(
|
||||
ctx, "Stream already completed, returning directly, session ID: %s, message ID: %s", sessionID, messageID,
|
||||
)
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"id": message.ID,
|
||||
"role": message.Role,
|
||||
"content": message.Content,
|
||||
"created_at": message.CreatedAt,
|
||||
"done": true,
|
||||
"error": "No stream events found",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
logger.Infof(
|
||||
ctx, "Preparing to set SSE headers and send stream data, session ID: %s, message ID: %s", sessionID, messageID,
|
||||
ctx, "Preparing to replay %d events and continue streaming, session ID: %s, message ID: %s",
|
||||
len(events), sessionID, messageID,
|
||||
)
|
||||
|
||||
// Send knowledge references first if available
|
||||
if len(streamInfo.KnowledgeReferences) > 0 {
|
||||
logger.Debug(ctx, "Sending knowledge references")
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: types.ResponseTypeReferences,
|
||||
Done: false,
|
||||
KnowledgeReferences: streamInfo.KnowledgeReferences,
|
||||
})
|
||||
// Set headers for SSE
|
||||
c.Header("Content-Type", "text/event-stream")
|
||||
c.Header("Cache-Control", "no-cache")
|
||||
c.Header("Connection", "keep-alive")
|
||||
c.Header("X-Accel-Buffering", "no")
|
||||
|
||||
// Check if stream is already completed
|
||||
streamCompleted := false
|
||||
for _, evt := range events {
|
||||
if evt.Type == "complete" {
|
||||
streamCompleted = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Replay existing events
|
||||
if len(streamInfo.Events) > 0 {
|
||||
logger.Debugf(ctx, "Replaying %d existing events", len(streamInfo.Events))
|
||||
for _, evt := range streamInfo.Events {
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
Data: evt.Data,
|
||||
})
|
||||
logger.Debugf(ctx, "Replaying %d existing events", len(events))
|
||||
for _, evt := range events {
|
||||
response := &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
Data: evt.Data,
|
||||
}
|
||||
}
|
||||
|
||||
// Create channels to monitor event updates
|
||||
eventIndexCh := make(chan int, 10)
|
||||
doneCh := make(chan bool, 1)
|
||||
|
||||
logger.Debug(ctx, "Starting event update monitoring")
|
||||
|
||||
// Start a goroutine to monitor for new events
|
||||
go func() {
|
||||
ticker := time.NewTicker(100 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
currentEventCount := len(streamInfo.Events)
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
latestStreamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Failed to get stream data: %v", err)
|
||||
doneCh <- true
|
||||
return
|
||||
}
|
||||
|
||||
if latestStreamInfo == nil {
|
||||
logger.Debug(ctx, "Stream no longer exists")
|
||||
doneCh <- true
|
||||
return
|
||||
}
|
||||
|
||||
if latestStreamInfo.IsCompleted {
|
||||
logger.Debug(ctx, "Stream completed")
|
||||
doneCh <- true
|
||||
return
|
||||
}
|
||||
|
||||
// Check for new events
|
||||
if len(latestStreamInfo.Events) > currentEventCount {
|
||||
eventIndexCh <- currentEventCount
|
||||
currentEventCount = len(latestStreamInfo.Events)
|
||||
logger.Debugf(ctx, "Detected %d new events", len(latestStreamInfo.Events)-currentEventCount)
|
||||
}
|
||||
|
||||
case <-c.Request.Context().Done():
|
||||
logger.Debug(ctx, "Client connection closed")
|
||||
return
|
||||
// Special handling for references event
|
||||
if evt.Type == types.ResponseTypeReferences {
|
||||
if refs, ok := evt.Data["references"].(types.References); ok {
|
||||
response.KnowledgeReferences = refs
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
logger.Info(ctx, "Starting stream response")
|
||||
c.SSEvent("message", response)
|
||||
c.Writer.Flush()
|
||||
}
|
||||
|
||||
// Stream new events to client
|
||||
c.Stream(func(w io.Writer) bool {
|
||||
// If stream is already completed, send final event and return
|
||||
if streamCompleted {
|
||||
logger.Infof(ctx, "Stream already completed, session ID: %s, message ID: %s", sessionID, messageID)
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: "",
|
||||
Done: true,
|
||||
})
|
||||
c.Writer.Flush()
|
||||
return
|
||||
}
|
||||
|
||||
// Continue polling for new events
|
||||
logger.Debug(ctx, "Starting event update monitoring")
|
||||
ticker := time.NewTicker(100 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-c.Request.Context().Done():
|
||||
logger.Debug(ctx, "Client connection closed")
|
||||
return false
|
||||
return
|
||||
|
||||
case <-doneCh:
|
||||
logger.Debug(ctx, "Stream completed, sending completion notification")
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: "",
|
||||
Done: true,
|
||||
})
|
||||
return false
|
||||
|
||||
case startIdx := <-eventIndexCh:
|
||||
// Send new events
|
||||
latestStreamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
|
||||
if err == nil && latestStreamInfo != nil {
|
||||
for i := startIdx; i < len(latestStreamInfo.Events); i++ {
|
||||
evt := latestStreamInfo.Events[i]
|
||||
logger.Debugf(ctx, "Sending new event: %s", evt.Type)
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
Data: evt.Data,
|
||||
})
|
||||
}
|
||||
case <-ticker.C:
|
||||
// Get new events from current offset
|
||||
newEvents, newOffset, err := h.streamManager.GetEvents(ctx, sessionID, messageID, currentOffset)
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Failed to get new events: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Send new events
|
||||
streamCompletedNow := false
|
||||
for _, evt := range newEvents {
|
||||
response := &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
Data: evt.Data,
|
||||
}
|
||||
|
||||
// Special handling for references event
|
||||
if evt.Type == types.ResponseTypeReferences {
|
||||
if refs, ok := evt.Data["references"].(types.References); ok {
|
||||
response.KnowledgeReferences = refs
|
||||
}
|
||||
}
|
||||
|
||||
// Check for completion event
|
||||
if evt.Type == "complete" {
|
||||
streamCompletedNow = true
|
||||
}
|
||||
|
||||
c.SSEvent("message", response)
|
||||
c.Writer.Flush()
|
||||
}
|
||||
|
||||
// Update offset
|
||||
currentOffset = newOffset
|
||||
|
||||
// If stream completed, send final event and exit
|
||||
if streamCompletedNow {
|
||||
logger.Infof(ctx, "Stream completed, session ID: %s, message ID: %s", sessionID, messageID)
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: message.RequestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: "",
|
||||
Done: true,
|
||||
})
|
||||
c.Writer.Flush()
|
||||
return
|
||||
}
|
||||
return true
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// KnowledgeQA handles knowledge base question answering requests with LLM summarization
|
||||
@@ -750,7 +735,6 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
|
||||
RequestID: c.GetString(types.RequestIDContextKey.String()),
|
||||
IsCompleted: false,
|
||||
}
|
||||
defer h.completeAssistantMessage(ctx, assistantMessage)
|
||||
|
||||
// Validate query content
|
||||
if request.Query == "" {
|
||||
@@ -761,50 +745,52 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
|
||||
|
||||
logger.Infof(ctx, "Knowledge QA request, session ID: %s, query: %s", sessionID, request.Query)
|
||||
|
||||
// Get request ID for title generation
|
||||
requestID := c.GetString(types.RequestIDContextKey.String())
|
||||
|
||||
// Get session to check if title needs to be generated
|
||||
// Get session to prepare knowledge base IDs
|
||||
session, err := h.sessionService.GetSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
logger.Errorf(ctx, "Failed to get session, session ID: %s, error: %v", sessionID, err)
|
||||
// Continue anyway - this is not critical
|
||||
} else {
|
||||
// Start async title generation if session has no title
|
||||
if session.Title == "" {
|
||||
logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
|
||||
// Use a simple event bus for title generation
|
||||
titleEventBus := event.NewEventBus()
|
||||
// Subscribe to title events and push to SSE
|
||||
titleEventBus.On(event.EventSessionTitle, func(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.SessionTitleData)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
// Send title update via SSE
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeSessionTitle,
|
||||
Content: data.Title,
|
||||
Done: true,
|
||||
Data: map[string]interface{}{
|
||||
"session_id": data.SessionID,
|
||||
"title": data.Title,
|
||||
},
|
||||
})
|
||||
c.Writer.Flush()
|
||||
return nil
|
||||
})
|
||||
h.sessionService.GenerateTitleAsync(ctx, session, request.Query, titleEventBus)
|
||||
}
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
// Prepare knowledge base IDs
|
||||
knowledgeBaseIDs := request.KnowledgeBaseIDs
|
||||
if len(knowledgeBaseIDs) == 0 && session.KnowledgeBaseID != "" {
|
||||
knowledgeBaseIDs = []string{session.KnowledgeBaseID}
|
||||
logger.Infof(ctx, "No knowledge base IDs in request, using session default: %s", session.KnowledgeBaseID)
|
||||
}
|
||||
|
||||
// Use shared function to handle KnowledgeQA request
|
||||
h.handleKnowledgeQARequest(ctx, c, session, request.Query, knowledgeBaseIDs, assistantMessage, true)
|
||||
}
|
||||
|
||||
// completeAssistantMessage marks an assistant message as complete and updates it
|
||||
func (h *SessionHandler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
|
||||
assistantMessage.UpdatedAt = time.Now()
|
||||
assistantMessage.IsCompleted = true
|
||||
_ = h.messageService.UpdateMessage(ctx, assistantMessage)
|
||||
}
|
||||
|
||||
// handleKnowledgeQARequest handles a KnowledgeQA request with the given parameters
|
||||
// This is a shared function used by both KnowledgeQA endpoint and AgentQA fallback
|
||||
func (h *SessionHandler) handleKnowledgeQARequest(
|
||||
ctx context.Context,
|
||||
c *gin.Context,
|
||||
session *types.Session,
|
||||
query string,
|
||||
knowledgeBaseIDs []string,
|
||||
assistantMessage *types.Message,
|
||||
generateTitle bool, // Whether to generate title if session has no title
|
||||
) {
|
||||
sessionID := session.ID
|
||||
requestID := c.GetString(types.RequestIDContextKey.String())
|
||||
|
||||
// Create user message
|
||||
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
|
||||
SessionID: sessionID,
|
||||
Role: "user",
|
||||
Content: request.Query,
|
||||
RequestID: c.GetString(types.RequestIDContextKey.String()),
|
||||
Content: query,
|
||||
RequestID: requestID,
|
||||
CreatedAt: time.Now(),
|
||||
IsCompleted: true,
|
||||
}); err != nil {
|
||||
@@ -818,14 +804,6 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
logger.Infof(ctx, "Calling knowledge QA service, session ID: %s", sessionID)
|
||||
|
||||
// Prepare knowledge base IDs
|
||||
knowledgeBaseIDs := request.KnowledgeBaseIDs
|
||||
if len(knowledgeBaseIDs) == 0 && session.KnowledgeBaseID != "" {
|
||||
knowledgeBaseIDs = []string{session.KnowledgeBaseID}
|
||||
logger.Infof(ctx, "No knowledge base IDs in request, using session default: %s", session.KnowledgeBaseID)
|
||||
}
|
||||
|
||||
// Validate knowledge bases
|
||||
if len(knowledgeBaseIDs) == 0 {
|
||||
@@ -836,89 +814,76 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
|
||||
|
||||
logger.Infof(ctx, "Using knowledge bases: %v", knowledgeBaseIDs)
|
||||
|
||||
// Call service to perform knowledge QA
|
||||
searchResults, respCh, err := h.sessionService.KnowledgeQA(ctx, session, request.Query, knowledgeBaseIDs)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, nil)
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
assistantMessage.KnowledgeReferences = searchResults
|
||||
|
||||
// Register new stream with stream manager
|
||||
if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
|
||||
logger.GetLogger(ctx).Error("Register stream failed", "error", err)
|
||||
}
|
||||
|
||||
// Set headers for SSE
|
||||
c.Header("Content-Type", "text/event-stream")
|
||||
c.Header("Cache-Control", "no-cache")
|
||||
c.Header("Connection", "keep-alive")
|
||||
c.Header("X-Accel-Buffering", "no")
|
||||
|
||||
// Send knowledge references if available
|
||||
if len(searchResults) > 0 {
|
||||
logger.Debugf(ctx, "Sending reference content, total %d", len(searchResults))
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeReferences,
|
||||
KnowledgeReferences: searchResults,
|
||||
})
|
||||
c.Writer.Flush()
|
||||
} else {
|
||||
logger.Debug(ctx, "No reference content to send")
|
||||
// Create dedicated EventBus for this request
|
||||
eventBus := event.NewEventBus()
|
||||
asyncCtx := logger.CloneContext(ctx)
|
||||
|
||||
// Create stream handler with dedicated EventBus
|
||||
streamHandler := NewAgentStreamHandler(
|
||||
asyncCtx, sessionID, assistantMessage.ID, requestID,
|
||||
assistantMessage, h.streamManager, eventBus,
|
||||
)
|
||||
|
||||
// Subscribe to events on the dedicated EventBus
|
||||
streamHandler.Subscribe()
|
||||
|
||||
// Generate title if needed
|
||||
if generateTitle && session.Title == "" {
|
||||
logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
|
||||
h.sessionService.GenerateTitleAsync(asyncCtx, session, query, eventBus)
|
||||
}
|
||||
|
||||
// Process streamed response
|
||||
func() {
|
||||
eventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.AgentFinalAnswerData)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
assistantMessage.Content += data.Content
|
||||
if data.Done {
|
||||
logger.Infof(asyncCtx, "Knowledge QA service completed for session: %s", sessionID)
|
||||
h.completeAssistantMessage(asyncCtx, assistantMessage)
|
||||
return nil
|
||||
}
|
||||
return nil
|
||||
})
|
||||
|
||||
// Call service to perform knowledge QA (async, emits events)
|
||||
go func() {
|
||||
defer func() {
|
||||
// Mark stream as completed when done
|
||||
if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessage.ID); err != nil {
|
||||
logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
|
||||
if r := recover(); r != nil {
|
||||
logger.ErrorWithFields(asyncCtx, errors.NewInternalServerError("Knowledge QA service panicked"), nil)
|
||||
}
|
||||
}()
|
||||
for response := range respCh {
|
||||
response.ID = requestID
|
||||
c.SSEvent("message", response)
|
||||
c.Writer.Flush()
|
||||
if response.ResponseType == types.ResponseTypeAnswer {
|
||||
assistantMessage.Content += response.Content
|
||||
// Push event to stream for replay on refresh
|
||||
if err := h.streamManager.PushEvent(
|
||||
ctx, sessionID, assistantMessage.ID, interfaces.StreamEvent{
|
||||
ID: uuid.New().String(),
|
||||
Type: response.ResponseType,
|
||||
Content: response.Content,
|
||||
Done: response.Done,
|
||||
Timestamp: time.Now(),
|
||||
},
|
||||
); err != nil {
|
||||
logger.GetLogger(ctx).Error("Push answer event to stream failed", "error", err)
|
||||
}
|
||||
}
|
||||
if response.ResponseType == types.ResponseTypeReferences {
|
||||
// Update references
|
||||
if err := h.streamManager.UpdateReferences(
|
||||
ctx, sessionID, assistantMessage.ID, searchResults,
|
||||
); err != nil {
|
||||
logger.GetLogger(ctx).Error("Update stream references failed", "error", err)
|
||||
}
|
||||
}
|
||||
err := h.sessionService.KnowledgeQA(asyncCtx, session, query, knowledgeBaseIDs, assistantMessage.ID, eventBus)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(asyncCtx, err, nil)
|
||||
// Emit error event to dedicated EventBus
|
||||
eventBus.Emit(asyncCtx, event.Event{
|
||||
Type: event.EventError,
|
||||
SessionID: sessionID,
|
||||
Data: event.ErrorData{
|
||||
Error: err.Error(),
|
||||
Stage: "knowledge_qa_execution",
|
||||
SessionID: sessionID,
|
||||
},
|
||||
})
|
||||
return
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// completeAssistantMessage marks an assistant message as complete and updates it
|
||||
func (h *SessionHandler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
|
||||
assistantMessage.UpdatedAt = time.Now()
|
||||
assistantMessage.IsCompleted = true
|
||||
_ = h.messageService.UpdateMessage(ctx, assistantMessage)
|
||||
// Handle events for SSE (blocking until connection is done)
|
||||
h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID, requestID)
|
||||
}
|
||||
|
||||
// AgentQA handles agent-based question answering with conversation history and streaming
|
||||
func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
ctx := logger.CloneContext(c.Request.Context())
|
||||
|
||||
logger.Info(ctx, "Start processing agent QA request")
|
||||
|
||||
// Get session ID from URL parameter
|
||||
@@ -937,15 +902,6 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
|
||||
// Create assistant message
|
||||
assistantMessage := &types.Message{
|
||||
SessionID: sessionID,
|
||||
Role: "assistant",
|
||||
RequestID: c.GetString(types.RequestIDContextKey.String()),
|
||||
IsCompleted: false,
|
||||
}
|
||||
defer h.completeAssistantMessage(ctx, assistantMessage)
|
||||
|
||||
// Validate query content
|
||||
if request.Query == "" {
|
||||
logger.Error(ctx, "Query content is empty")
|
||||
@@ -963,6 +919,14 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
|
||||
// Create assistant message
|
||||
assistantMessage := &types.Message{
|
||||
SessionID: sessionID,
|
||||
Role: "assistant",
|
||||
RequestID: c.GetString(types.RequestIDContextKey.String()),
|
||||
IsCompleted: false,
|
||||
}
|
||||
|
||||
// Initialize AgentConfig if it doesn't exist
|
||||
if session.AgentConfig == nil {
|
||||
session.AgentConfig = &types.SessionAgentConfig{}
|
||||
@@ -1051,86 +1015,8 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
|
||||
logger.Infof(ctx, "Delegating to KnowledgeQA with knowledge bases: %v", knowledgeBaseIDs)
|
||||
|
||||
// Create user message
|
||||
requestID := c.GetString(types.RequestIDContextKey.String())
|
||||
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
|
||||
SessionID: sessionID,
|
||||
Role: "user",
|
||||
Content: request.Query,
|
||||
RequestID: requestID,
|
||||
CreatedAt: time.Now(),
|
||||
IsCompleted: true,
|
||||
}); err != nil {
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
// Create assistant message (response)
|
||||
assistantMessage.CreatedAt = time.Now()
|
||||
if _, err := h.messageService.CreateMessage(ctx, assistantMessage); err != nil {
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
|
||||
// Call KnowledgeQA service
|
||||
searchResults, respCh, err := h.sessionService.KnowledgeQA(ctx, session, request.Query, knowledgeBaseIDs)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, nil)
|
||||
c.Error(errors.NewInternalServerError(err.Error()))
|
||||
return
|
||||
}
|
||||
assistantMessage.KnowledgeReferences = searchResults
|
||||
|
||||
// Register new stream with stream manager
|
||||
if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
|
||||
logger.GetLogger(ctx).Error("Register stream failed", "error", err)
|
||||
}
|
||||
|
||||
// Set headers for SSE
|
||||
c.Header("Content-Type", "text/event-stream")
|
||||
c.Header("Cache-Control", "no-cache")
|
||||
c.Header("Connection", "keep-alive")
|
||||
c.Header("X-Accel-Buffering", "no")
|
||||
|
||||
// Send knowledge references if available
|
||||
if len(searchResults) > 0 {
|
||||
logger.Debugf(ctx, "Sending reference content, total %d", len(searchResults))
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeReferences,
|
||||
KnowledgeReferences: searchResults,
|
||||
})
|
||||
c.Writer.Flush()
|
||||
} else {
|
||||
logger.Debug(ctx, "No reference content to send")
|
||||
}
|
||||
|
||||
// Process streamed response
|
||||
func() {
|
||||
defer func() {
|
||||
// Mark stream as completed when done
|
||||
if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessage.ID); err != nil {
|
||||
logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
|
||||
}
|
||||
}()
|
||||
for response := range respCh {
|
||||
response.ID = requestID
|
||||
c.SSEvent("message", response)
|
||||
c.Writer.Flush()
|
||||
if response.ResponseType == types.ResponseTypeAnswer {
|
||||
assistantMessage.Content += response.Content
|
||||
}
|
||||
}
|
||||
assistantMessage.IsCompleted = true
|
||||
}()
|
||||
|
||||
// Update message with final content and references
|
||||
assistantMessage.UpdatedAt = time.Now()
|
||||
if err := h.messageService.UpdateMessage(ctx, assistantMessage); err != nil {
|
||||
logger.Errorf(ctx, "Failed to update assistant message: %v", err)
|
||||
}
|
||||
|
||||
logger.Infof(ctx, "KnowledgeQA delegation completed for session: %s", sessionID)
|
||||
// Use shared function to handle KnowledgeQA request (no title generation for AgentQA fallback)
|
||||
h.handleKnowledgeQARequest(ctx, c, session, request.Query, knowledgeBaseIDs, assistantMessage, false)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -1156,20 +1042,6 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
c.Header("Connection", "keep-alive")
|
||||
c.Header("X-Accel-Buffering", "no")
|
||||
|
||||
// Send agent query event to frontend via SSE to trigger loading state immediately
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeAgentQuery,
|
||||
Content: "Agent query processing started",
|
||||
Done: false,
|
||||
Data: map[string]interface{}{
|
||||
"session_id": sessionID,
|
||||
"query": request.Query,
|
||||
"request_id": requestID,
|
||||
},
|
||||
})
|
||||
c.Writer.Flush()
|
||||
|
||||
// Create user message
|
||||
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
|
||||
SessionID: sessionID,
|
||||
@@ -1194,17 +1066,12 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
|
||||
logger.Infof(ctx, "Calling agent QA service, session ID: %s", sessionID)
|
||||
|
||||
// Register new stream with stream manager
|
||||
if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
|
||||
logger.GetLogger(ctx).Error("Register stream failed", "error", err)
|
||||
}
|
||||
|
||||
// SSE headers already set earlier when sending agent_query event
|
||||
|
||||
eventBus := event.NewEventBus()
|
||||
// Create stream handler with dedicated EventBus BEFORE calling AgentQA
|
||||
streamHandler := NewAgentStreamHandler(
|
||||
ctx, c, sessionID, assistantMessage.ID, requestID,
|
||||
ctx, sessionID, assistantMessage.ID, requestID,
|
||||
assistantMessage, h.streamManager, eventBus,
|
||||
)
|
||||
|
||||
@@ -1214,36 +1081,23 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
// Start async title generation if session has no title
|
||||
if session.Title == "" {
|
||||
logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
|
||||
// Subscribe to title events on the dedicated EventBus
|
||||
eventBus.On(event.EventSessionTitle, func(ctx context.Context, evt event.Event) error {
|
||||
data, ok := evt.Data.(event.SessionTitleData)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
// Send title update via SSE
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeSessionTitle,
|
||||
Content: data.Title,
|
||||
Done: true,
|
||||
Data: map[string]interface{}{
|
||||
"session_id": data.SessionID,
|
||||
"title": data.Title,
|
||||
},
|
||||
})
|
||||
c.Writer.Flush()
|
||||
return nil
|
||||
})
|
||||
h.sessionService.GenerateTitleAsync(ctx, session, request.Query, eventBus)
|
||||
}
|
||||
|
||||
// Call service to perform agent QA
|
||||
asyncCtx := logger.CloneContext(ctx)
|
||||
go func() {
|
||||
searchResults, err := h.sessionService.AgentQA(ctx, session, request.Query, assistantMessage.ID, eventBus)
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.ErrorWithFields(asyncCtx, errors.NewInternalServerError("Agent QA service panicked"), nil)
|
||||
}
|
||||
h.completeAssistantMessage(asyncCtx, assistantMessage)
|
||||
logger.Infof(asyncCtx, "Agent QA service completed for session: %s", sessionID)
|
||||
}()
|
||||
err := h.sessionService.AgentQA(asyncCtx, session, request.Query, assistantMessage.ID, eventBus)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, nil)
|
||||
logger.ErrorWithFields(asyncCtx, err, nil)
|
||||
// Emit error event to dedicated EventBus
|
||||
eventBus.Emit(ctx, event.Event{
|
||||
eventBus.Emit(asyncCtx, event.Event{
|
||||
Type: event.EventError,
|
||||
SessionID: sessionID,
|
||||
Data: event.ErrorData{
|
||||
@@ -1254,26 +1108,94 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
|
||||
})
|
||||
return
|
||||
}
|
||||
assistantMessage.KnowledgeReferences = searchResults
|
||||
}()
|
||||
|
||||
// Handle events for SSE (blocking until connection is done)
|
||||
h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID)
|
||||
h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID, requestID)
|
||||
}
|
||||
|
||||
// handleAgentEventsForSSEWithHandler handles agent events for SSE streaming using an existing handler
|
||||
// The handler is already subscribed to events and AgentQA is already running
|
||||
// This function polls StreamManager and pushes events to SSE, allowing graceful handling of disconnections
|
||||
func (h *SessionHandler) handleAgentEventsForSSEWithHandler(
|
||||
ctx context.Context,
|
||||
c *gin.Context,
|
||||
sessionID, assistantMessageID string,
|
||||
sessionID, assistantMessageID, requestID string,
|
||||
) {
|
||||
// Wait for completion - events are already being handled by streamHandler
|
||||
// The connection will be closed when the gin context is done
|
||||
<-c.Request.Context().Done()
|
||||
ticker := time.NewTicker(100 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
// Complete stream when done
|
||||
if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessageID); err != nil {
|
||||
logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
|
||||
lastOffset := 0
|
||||
log := logger.GetLogger(ctx)
|
||||
|
||||
log.Infof("Starting pull-based SSE streaming for session=%s, message=%s", sessionID, assistantMessageID)
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-c.Request.Context().Done():
|
||||
// Connection closed, exit gracefully without panic
|
||||
log.Infof("Client disconnected, stopping SSE streaming for session=%s, message=%s", sessionID, assistantMessageID)
|
||||
return
|
||||
|
||||
case <-ticker.C:
|
||||
// Get new events from StreamManager using offset
|
||||
events, newOffset, err := h.streamManager.GetEvents(ctx, sessionID, assistantMessageID, lastOffset)
|
||||
if err != nil {
|
||||
log.Warnf("Failed to get events from stream: %v", err)
|
||||
continue
|
||||
}
|
||||
|
||||
// Send any new events
|
||||
streamCompleted := false
|
||||
for _, evt := range events {
|
||||
// Build StreamResponse from StreamEvent
|
||||
response := &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: evt.Type,
|
||||
Content: evt.Content,
|
||||
Done: evt.Done,
|
||||
Data: evt.Data,
|
||||
}
|
||||
|
||||
// Special handling for references event
|
||||
if evt.Type == types.ResponseTypeReferences {
|
||||
if refs, ok := evt.Data["references"].(types.References); ok {
|
||||
response.KnowledgeReferences = refs
|
||||
}
|
||||
}
|
||||
|
||||
// Check for completion event
|
||||
if evt.Type == "complete" {
|
||||
streamCompleted = true
|
||||
}
|
||||
|
||||
// Check if connection is still alive before writing
|
||||
if c.Request.Context().Err() != nil {
|
||||
log.Info("Connection closed during event sending, stopping")
|
||||
return
|
||||
}
|
||||
|
||||
c.SSEvent("message", response)
|
||||
c.Writer.Flush()
|
||||
}
|
||||
|
||||
// Update offset
|
||||
lastOffset = newOffset
|
||||
|
||||
// Check if stream is completed
|
||||
if streamCompleted {
|
||||
log.Infof("Stream completed for session=%s, message=%s", sessionID, assistantMessageID)
|
||||
|
||||
// Send final completion signal
|
||||
c.SSEvent("message", &types.StreamResponse{
|
||||
ID: requestID,
|
||||
ResponseType: types.ResponseTypeAnswer,
|
||||
Content: "",
|
||||
Done: true,
|
||||
})
|
||||
c.Writer.Flush()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,161 +5,106 @@ import (
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
)
|
||||
|
||||
// 内存流信息
|
||||
type memoryStreamInfo struct {
|
||||
sessionID string
|
||||
requestID string
|
||||
query string
|
||||
events []interfaces.StreamEvent
|
||||
knowledgeReferences types.References
|
||||
lastUpdated time.Time
|
||||
isCompleted bool
|
||||
// memoryStreamData holds stream events in memory
|
||||
type memoryStreamData struct {
|
||||
events []interfaces.StreamEvent
|
||||
lastUpdated time.Time
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
// MemoryStreamManager 基于内存的流管理器实现
|
||||
// MemoryStreamManager implements StreamManager using in-memory storage
|
||||
type MemoryStreamManager struct {
|
||||
// 会话ID -> 请求ID -> 流数据
|
||||
activeStreams map[string]map[string]*memoryStreamInfo
|
||||
mu sync.RWMutex
|
||||
// Map: sessionID -> messageID -> stream data
|
||||
streams map[string]map[string]*memoryStreamData
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
// NewMemoryStreamManager 创建一个新的内存流管理器
|
||||
// NewMemoryStreamManager creates a new in-memory stream manager
|
||||
func NewMemoryStreamManager() *MemoryStreamManager {
|
||||
return &MemoryStreamManager{
|
||||
activeStreams: make(map[string]map[string]*memoryStreamInfo),
|
||||
streams: make(map[string]map[string]*memoryStreamData),
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterStream 注册一个新的流
|
||||
func (m *MemoryStreamManager) RegisterStream(ctx context.Context, sessionID, requestID, query string) error {
|
||||
// getOrCreateStream gets or creates stream data
|
||||
func (m *MemoryStreamManager) getOrCreateStream(sessionID, messageID string) *memoryStreamData {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
info := &memoryStreamInfo{
|
||||
sessionID: sessionID,
|
||||
requestID: requestID,
|
||||
query: query,
|
||||
lastUpdated: time.Now(),
|
||||
if _, exists := m.streams[sessionID]; !exists {
|
||||
m.streams[sessionID] = make(map[string]*memoryStreamData)
|
||||
}
|
||||
|
||||
if _, exists := m.activeStreams[sessionID]; !exists {
|
||||
m.activeStreams[sessionID] = make(map[string]*memoryStreamInfo)
|
||||
}
|
||||
|
||||
m.activeStreams[sessionID][requestID] = info
|
||||
return nil
|
||||
}
|
||||
|
||||
// PushEvent 推送事件到流(追加模式)
|
||||
func (m *MemoryStreamManager) PushEvent(ctx context.Context,
|
||||
sessionID, requestID string, event interfaces.StreamEvent,
|
||||
) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
if sessionMap, exists := m.activeStreams[sessionID]; exists {
|
||||
if stream, found := sessionMap[requestID]; found {
|
||||
stream.events = append(stream.events, event)
|
||||
stream.lastUpdated = time.Now()
|
||||
if _, exists := m.streams[sessionID][messageID]; !exists {
|
||||
m.streams[sessionID][messageID] = &memoryStreamData{
|
||||
events: make([]interfaces.StreamEvent, 0),
|
||||
lastUpdated: time.Now(),
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
||||
return m.streams[sessionID][messageID]
|
||||
}
|
||||
|
||||
// ReplaceEvent 通过 ID 替换事件(用于流式进度更新)
|
||||
func (m *MemoryStreamManager) ReplaceEvent(ctx context.Context,
|
||||
sessionID, requestID string, event interfaces.StreamEvent,
|
||||
) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
if sessionMap, exists := m.activeStreams[sessionID]; exists {
|
||||
if stream, found := sessionMap[requestID]; found {
|
||||
// 通过 ID 精确查找并替换
|
||||
replaced := false
|
||||
for i := range stream.events {
|
||||
if stream.events[i].ID == event.ID {
|
||||
// 找到了,替换
|
||||
stream.events[i] = event
|
||||
replaced = true
|
||||
break
|
||||
}
|
||||
}
|
||||
// 没找到,追加
|
||||
if !replaced {
|
||||
stream.events = append(stream.events, event)
|
||||
}
|
||||
stream.lastUpdated = time.Now()
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateReferences 更新知识引用
|
||||
func (m *MemoryStreamManager) UpdateReferences(ctx context.Context,
|
||||
sessionID, requestID string, references types.References,
|
||||
) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
if sessionMap, exists := m.activeStreams[sessionID]; exists {
|
||||
if stream, found := sessionMap[requestID]; found {
|
||||
stream.knowledgeReferences = references
|
||||
stream.lastUpdated = time.Now()
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CompleteStream 完成流
|
||||
func (m *MemoryStreamManager) CompleteStream(ctx context.Context, sessionID, requestID string) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
if sessionMap, exists := m.activeStreams[sessionID]; exists {
|
||||
if stream, found := sessionMap[requestID]; found {
|
||||
stream.isCompleted = true
|
||||
// 30s 后删除流
|
||||
go func() {
|
||||
time.Sleep(30 * time.Second)
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
delete(sessionMap, requestID)
|
||||
if len(sessionMap) == 0 {
|
||||
delete(m.activeStreams, sessionID)
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStream 获取特定流
|
||||
func (m *MemoryStreamManager) GetStream(ctx context.Context,
|
||||
sessionID, requestID string,
|
||||
) (*interfaces.StreamInfo, error) {
|
||||
// getStream gets existing stream data (returns nil if not found)
|
||||
func (m *MemoryStreamManager) getStream(sessionID, messageID string) *memoryStreamData {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
|
||||
if sessionMap, exists := m.activeStreams[sessionID]; exists {
|
||||
if stream, found := sessionMap[requestID]; found {
|
||||
return &interfaces.StreamInfo{
|
||||
SessionID: stream.sessionID,
|
||||
RequestID: stream.requestID,
|
||||
Query: stream.query,
|
||||
Events: stream.events,
|
||||
KnowledgeReferences: stream.knowledgeReferences,
|
||||
LastUpdated: stream.lastUpdated,
|
||||
IsCompleted: stream.isCompleted,
|
||||
}, nil
|
||||
}
|
||||
if sessionMap, exists := m.streams[sessionID]; exists {
|
||||
return sessionMap[messageID]
|
||||
}
|
||||
return nil, nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// 确保实现了接口
|
||||
// AppendEvent appends a single event to the stream
|
||||
func (m *MemoryStreamManager) AppendEvent(ctx context.Context, sessionID, messageID string, event interfaces.StreamEvent) error {
|
||||
stream := m.getOrCreateStream(sessionID, messageID)
|
||||
|
||||
stream.mu.Lock()
|
||||
defer stream.mu.Unlock()
|
||||
|
||||
// Set timestamp if not already set
|
||||
if event.Timestamp.IsZero() {
|
||||
event.Timestamp = time.Now()
|
||||
}
|
||||
|
||||
// Append event
|
||||
stream.events = append(stream.events, event)
|
||||
stream.lastUpdated = time.Now()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetEvents gets events starting from offset
|
||||
// Returns: events slice, next offset, error
|
||||
func (m *MemoryStreamManager) GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]interfaces.StreamEvent, int, error) {
|
||||
stream := m.getStream(sessionID, messageID)
|
||||
if stream == nil {
|
||||
// Stream doesn't exist yet
|
||||
return []interfaces.StreamEvent{}, fromOffset, nil
|
||||
}
|
||||
|
||||
stream.mu.RLock()
|
||||
defer stream.mu.RUnlock()
|
||||
|
||||
// Check if offset is beyond current events
|
||||
if fromOffset >= len(stream.events) {
|
||||
return []interfaces.StreamEvent{}, fromOffset, nil
|
||||
}
|
||||
|
||||
// Get events from offset to end
|
||||
events := stream.events[fromOffset:]
|
||||
nextOffset := len(stream.events)
|
||||
|
||||
// Return copy of events to avoid race conditions
|
||||
eventsCopy := make([]interfaces.StreamEvent, len(events))
|
||||
copy(eventsCopy, events)
|
||||
|
||||
return eventsCopy, nextOffset, nil
|
||||
}
|
||||
|
||||
// Ensure MemoryStreamManager implements StreamManager interface
|
||||
var _ interfaces.StreamManager = (*MemoryStreamManager)(nil)
|
||||
|
||||
@@ -6,30 +6,18 @@ import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// redisStreamInfo Redis存储的流信息
|
||||
type redisStreamInfo struct {
|
||||
SessionID string `json:"session_id"`
|
||||
RequestID string `json:"request_id"`
|
||||
Query string `json:"query"`
|
||||
Events []interfaces.StreamEvent `json:"events"`
|
||||
KnowledgeReferences types.References `json:"knowledge_references"`
|
||||
LastUpdated time.Time `json:"last_updated"`
|
||||
IsCompleted bool `json:"is_completed"`
|
||||
}
|
||||
|
||||
// RedisStreamManager 基于Redis的流管理器实现
|
||||
// RedisStreamManager implements StreamManager using Redis Lists for append-only event streaming
|
||||
type RedisStreamManager struct {
|
||||
client *redis.Client
|
||||
ttl time.Duration // 流数据在Redis中的过期时间
|
||||
prefix string // Redis键前缀
|
||||
ttl time.Duration // TTL for stream data in Redis
|
||||
prefix string // Redis key prefix
|
||||
}
|
||||
|
||||
// NewRedisStreamManager 创建一个新的Redis流管理器
|
||||
// NewRedisStreamManager creates a new Redis-based stream manager
|
||||
func NewRedisStreamManager(redisAddr, redisPassword string,
|
||||
redisDB int, prefix string, ttl time.Duration,
|
||||
) (*RedisStreamManager, error) {
|
||||
@@ -39,18 +27,18 @@ func NewRedisStreamManager(redisAddr, redisPassword string,
|
||||
DB: redisDB,
|
||||
})
|
||||
|
||||
// 验证连接
|
||||
// Verify connection
|
||||
_, err := client.Ping(context.Background()).Result()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("连接Redis失败: %w", err)
|
||||
return nil, fmt.Errorf("failed to connect to Redis: %w", err)
|
||||
}
|
||||
|
||||
if ttl == 0 {
|
||||
ttl = 24 * time.Hour // 默认TTL为24小时
|
||||
ttl = 24 * time.Hour // Default TTL: 24 hours
|
||||
}
|
||||
|
||||
if prefix == "" {
|
||||
prefix = "stream:" // 默认前缀
|
||||
prefix = "stream:events" // Default prefix
|
||||
}
|
||||
|
||||
return &RedisStreamManager{
|
||||
@@ -60,206 +48,81 @@ func NewRedisStreamManager(redisAddr, redisPassword string,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 构建Redis键
|
||||
func (r *RedisStreamManager) buildKey(sessionID, requestID string) string {
|
||||
return fmt.Sprintf("%s:%s:%s", r.prefix, sessionID, requestID)
|
||||
// buildKey builds the Redis key for event list
|
||||
func (r *RedisStreamManager) buildKey(sessionID, messageID string) string {
|
||||
return fmt.Sprintf("%s:%s:%s", r.prefix, sessionID, messageID)
|
||||
}
|
||||
|
||||
// RegisterStream 注册一个新的流
|
||||
func (r *RedisStreamManager) RegisterStream(ctx context.Context, sessionID, requestID, query string) error {
|
||||
info := &redisStreamInfo{
|
||||
SessionID: sessionID,
|
||||
RequestID: requestID,
|
||||
Query: query,
|
||||
LastUpdated: time.Now(),
|
||||
// AppendEvent appends a single event to the stream using Redis RPush
|
||||
func (r *RedisStreamManager) AppendEvent(ctx context.Context, sessionID, messageID string, event interfaces.StreamEvent) error {
|
||||
key := r.buildKey(sessionID, messageID)
|
||||
|
||||
// Set timestamp if not already set
|
||||
if event.Timestamp.IsZero() {
|
||||
event.Timestamp = time.Now()
|
||||
}
|
||||
|
||||
data, err := json.Marshal(info)
|
||||
// Serialize event to JSON
|
||||
eventJSON, err := json.Marshal(event)
|
||||
if err != nil {
|
||||
return fmt.Errorf("序列化流信息失败: %w", err)
|
||||
return fmt.Errorf("failed to marshal event: %w", err)
|
||||
}
|
||||
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
return r.client.Set(ctx, key, data, r.ttl).Err()
|
||||
// Append to Redis list with RPush (O(1) operation)
|
||||
if err := r.client.RPush(ctx, key, eventJSON).Err(); err != nil {
|
||||
return fmt.Errorf("failed to append event to Redis: %w", err)
|
||||
}
|
||||
|
||||
// Set/refresh TTL on the key
|
||||
if err := r.client.Expire(ctx, key, r.ttl).Err(); err != nil {
|
||||
return fmt.Errorf("failed to set TTL: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// PushEvent 推送事件到流
|
||||
func (r *RedisStreamManager) PushEvent(ctx context.Context, sessionID, requestID string, event interfaces.StreamEvent) error {
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
// GetEvents gets events starting from offset using Redis LRange
|
||||
// Returns: events slice, next offset, error
|
||||
func (r *RedisStreamManager) GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]interfaces.StreamEvent, int, error) {
|
||||
key := r.buildKey(sessionID, messageID)
|
||||
|
||||
// 获取当前数据
|
||||
data, err := r.client.Get(ctx, key).Bytes()
|
||||
// Get all events from offset to end using LRange
|
||||
// LRange is inclusive, so fromOffset to -1 gets all remaining elements
|
||||
results, err := r.client.LRange(ctx, key, int64(fromOffset), -1).Result()
|
||||
if err != nil {
|
||||
if err == redis.Nil {
|
||||
return nil // 键不存在,可能已过期
|
||||
// Key doesn't exist - return empty slice
|
||||
return []interfaces.StreamEvent{}, fromOffset, nil
|
||||
}
|
||||
return fmt.Errorf("获取流数据失败: %w", err)
|
||||
return nil, fromOffset, fmt.Errorf("failed to get events from Redis: %w", err)
|
||||
}
|
||||
|
||||
var info redisStreamInfo
|
||||
if err := json.Unmarshal(data, &info); err != nil {
|
||||
return fmt.Errorf("解析流数据失败: %w", err)
|
||||
// No new events
|
||||
if len(results) == 0 {
|
||||
return []interfaces.StreamEvent{}, fromOffset, nil
|
||||
}
|
||||
|
||||
// 追加事件
|
||||
info.Events = append(info.Events, event)
|
||||
info.LastUpdated = time.Now()
|
||||
|
||||
// 保存回Redis
|
||||
updatedData, err := json.Marshal(info)
|
||||
if err != nil {
|
||||
return fmt.Errorf("序列化更新的流信息失败: %w", err)
|
||||
}
|
||||
|
||||
return r.client.Set(ctx, key, updatedData, r.ttl).Err()
|
||||
// Unmarshal events
|
||||
events := make([]interfaces.StreamEvent, 0, len(results))
|
||||
for _, result := range results {
|
||||
var event interfaces.StreamEvent
|
||||
if err := json.Unmarshal([]byte(result), &event); err != nil {
|
||||
// Log error but continue with other events
|
||||
continue
|
||||
}
|
||||
events = append(events, event)
|
||||
}
|
||||
|
||||
// ReplaceEvent 通过 ID 替换事件(用于流式进度更新)
|
||||
func (r *RedisStreamManager) ReplaceEvent(ctx context.Context, sessionID, requestID string, event interfaces.StreamEvent) error {
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
// Calculate next offset
|
||||
nextOffset := fromOffset + len(results)
|
||||
|
||||
// 获取当前数据
|
||||
data, err := r.client.Get(ctx, key).Bytes()
|
||||
if err != nil {
|
||||
if err == redis.Nil {
|
||||
return nil // 键不存在,可能已过期
|
||||
}
|
||||
return fmt.Errorf("获取流数据失败: %w", err)
|
||||
}
|
||||
|
||||
var info redisStreamInfo
|
||||
if err := json.Unmarshal(data, &info); err != nil {
|
||||
return fmt.Errorf("解析流数据失败: %w", err)
|
||||
}
|
||||
|
||||
// 通过 ID 精确查找并替换
|
||||
replaced := false
|
||||
for i := range info.Events {
|
||||
if info.Events[i].ID == event.ID {
|
||||
// 找到了,替换
|
||||
info.Events[i] = event
|
||||
replaced = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// 没找到,追加
|
||||
if !replaced {
|
||||
info.Events = append(info.Events, event)
|
||||
}
|
||||
|
||||
info.LastUpdated = time.Now()
|
||||
|
||||
// 保存回Redis
|
||||
updatedData, err := json.Marshal(info)
|
||||
if err != nil {
|
||||
return fmt.Errorf("序列化更新的流信息失败: %w", err)
|
||||
}
|
||||
|
||||
return r.client.Set(ctx, key, updatedData, r.ttl).Err()
|
||||
return events, nextOffset, nil
|
||||
}
|
||||
|
||||
// UpdateReferences 更新知识引用
|
||||
func (r *RedisStreamManager) UpdateReferences(ctx context.Context, sessionID, requestID string, references types.References) error {
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
|
||||
// 获取当前数据
|
||||
data, err := r.client.Get(ctx, key).Bytes()
|
||||
if err != nil {
|
||||
if err == redis.Nil {
|
||||
return nil // 键不存在,可能已过期
|
||||
}
|
||||
return fmt.Errorf("获取流数据失败: %w", err)
|
||||
}
|
||||
|
||||
var info redisStreamInfo
|
||||
if err := json.Unmarshal(data, &info); err != nil {
|
||||
return fmt.Errorf("解析流数据失败: %w", err)
|
||||
}
|
||||
|
||||
// 更新知识引用
|
||||
info.KnowledgeReferences = references
|
||||
info.LastUpdated = time.Now()
|
||||
|
||||
// 保存回Redis
|
||||
updatedData, err := json.Marshal(info)
|
||||
if err != nil {
|
||||
return fmt.Errorf("序列化更新的流信息失败: %w", err)
|
||||
}
|
||||
|
||||
return r.client.Set(ctx, key, updatedData, r.ttl).Err()
|
||||
}
|
||||
|
||||
// CompleteStream 完成流
|
||||
func (r *RedisStreamManager) CompleteStream(ctx context.Context, sessionID, requestID string) error {
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
|
||||
// 获取当前数据
|
||||
data, err := r.client.Get(ctx, key).Bytes()
|
||||
if err != nil {
|
||||
if err == redis.Nil {
|
||||
return nil // 键不存在,可能已过期
|
||||
}
|
||||
return fmt.Errorf("获取流数据失败: %w", err)
|
||||
}
|
||||
|
||||
var info redisStreamInfo
|
||||
if err := json.Unmarshal(data, &info); err != nil {
|
||||
return fmt.Errorf("解析流数据失败: %w", err)
|
||||
}
|
||||
|
||||
// 标记为完成
|
||||
info.IsCompleted = true
|
||||
info.LastUpdated = time.Now()
|
||||
|
||||
// 保存回Redis
|
||||
updatedData, err := json.Marshal(info)
|
||||
if err != nil {
|
||||
return fmt.Errorf("序列化更新的流信息失败: %w", err)
|
||||
}
|
||||
|
||||
// 30s 后删除流
|
||||
go func() {
|
||||
time.Sleep(30 * time.Second)
|
||||
r.client.Del(ctx, key)
|
||||
}()
|
||||
return r.client.Set(ctx, key, updatedData, r.ttl).Err()
|
||||
}
|
||||
|
||||
// GetStream 获取特定流
|
||||
func (r *RedisStreamManager) GetStream(ctx context.Context, sessionID, requestID string) (*interfaces.StreamInfo, error) {
|
||||
key := r.buildKey(sessionID, requestID)
|
||||
|
||||
// 获取数据
|
||||
data, err := r.client.Get(ctx, key).Bytes()
|
||||
if err != nil {
|
||||
if err == redis.Nil {
|
||||
return nil, nil // 键不存在
|
||||
}
|
||||
return nil, fmt.Errorf("获取流数据失败: %w", err)
|
||||
}
|
||||
|
||||
var info redisStreamInfo
|
||||
if err := json.Unmarshal(data, &info); err != nil {
|
||||
return nil, fmt.Errorf("解析流数据失败: %w", err)
|
||||
}
|
||||
|
||||
// 转换为接口结构
|
||||
return &interfaces.StreamInfo{
|
||||
SessionID: info.SessionID,
|
||||
RequestID: info.RequestID,
|
||||
Query: info.Query,
|
||||
Events: info.Events,
|
||||
KnowledgeReferences: info.KnowledgeReferences,
|
||||
LastUpdated: info.LastUpdated,
|
||||
IsCompleted: info.IsCompleted,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Close 关闭Redis连接
|
||||
// Close closes the Redis connection
|
||||
func (r *RedisStreamManager) Close() error {
|
||||
return r.client.Close()
|
||||
}
|
||||
|
||||
// 确保实现了接口
|
||||
// Ensure RedisStreamManager implements StreamManager interface
|
||||
var _ interfaces.StreamManager = (*RedisStreamManager)(nil)
|
||||
|
||||
@@ -20,20 +20,23 @@ type ChatManage struct {
|
||||
RerankTopK int `json:"rerank_top_k"` // Number of top results after reranking
|
||||
RerankThreshold float64 `json:"rerank_threshold"` // Minimum score threshold for reranked results
|
||||
|
||||
ChatModelID string `json:"chat_model_id"` // Model ID for chat completion
|
||||
ChatModelID string `json:"chat_model_id"` // ID of the chat model to use
|
||||
SummaryConfig SummaryConfig `json:"summary_config"` // Configuration for summary generation
|
||||
FallbackStrategy FallbackStrategy `json:"fallback_strategy"` // Strategy when no relevant results are found
|
||||
FallbackResponse string `json:"fallback_response"` // Default response when fallback occurs
|
||||
|
||||
// Internal fields for pipeline data processing
|
||||
SearchResult []*SearchResult `json:"-"` // Results from search phase
|
||||
RerankResult []*SearchResult `json:"-"` // Results after reranking
|
||||
MergeResult []*SearchResult `json:"-"` // Final merged results after all processing
|
||||
Entity []string `json:"-"` // List of identified entities
|
||||
GraphResult *GraphData `json:"-"` // Graph data from search phase
|
||||
UserContent string `json:"-"` // Processed user content
|
||||
ChatResponse *ChatResponse `json:"-"` // Final response from chat model
|
||||
ResponseChan <-chan StreamResponse `json:"-"` // Channel for streaming responses
|
||||
SearchResult []*SearchResult `json:"-"` // Results from search phase
|
||||
RerankResult []*SearchResult `json:"-"` // Results after reranking
|
||||
MergeResult []*SearchResult `json:"-"` // Final merged results after all processing
|
||||
Entity []string `json:"-"` // List of identified entities
|
||||
GraphResult *GraphData `json:"-"` // Graph data from search phase
|
||||
UserContent string `json:"-"` // Processed user content
|
||||
ChatResponse *ChatResponse `json:"-"` // Final response from chat model
|
||||
|
||||
// Event system for streaming responses
|
||||
EventBus EventBusInterface `json:"-"` // EventBus for emitting streaming events
|
||||
MessageID string `json:"-"` // Assistant message ID for event emission
|
||||
}
|
||||
|
||||
// Clone creates a deep copy of the ChatManage object
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
package types
|
||||
|
||||
import (
|
||||
"context"
|
||||
)
|
||||
|
||||
// EventHandler is a function that handles events
|
||||
type EventHandler func(ctx context.Context, evt Event) error
|
||||
|
||||
// Event represents an event in the system
|
||||
// This is a simplified version to avoid import cycle with event package
|
||||
type Event struct {
|
||||
ID string // Event ID
|
||||
Type EventType // Event type (uses EventType from chat_manage.go)
|
||||
SessionID string // Session ID
|
||||
Data interface{} // Event data
|
||||
Metadata map[string]interface{} // Event metadata
|
||||
RequestID string // Request ID
|
||||
}
|
||||
|
||||
// EventBusInterface defines the interface for event bus operations
|
||||
// This interface allows types package to use EventBus without importing the concrete type
|
||||
// and avoids circular dependencies
|
||||
type EventBusInterface interface {
|
||||
// On registers an event handler for a specific event type
|
||||
On(eventType EventType, handler EventHandler)
|
||||
|
||||
// Emit publishes an event to all registered handlers
|
||||
Emit(ctx context.Context, evt Event) error
|
||||
}
|
||||
@@ -28,16 +28,17 @@ type SessionService interface {
|
||||
GenerateTitleAsync(ctx context.Context, session *types.Session, userQuery string, eventBus *event.EventBus)
|
||||
// KnowledgeQA performs knowledge-based question answering
|
||||
// knowledgeBaseIDs: list of knowledge base IDs to search (supports multi-KB)
|
||||
// Events are emitted through eventBus (references, answer chunks, completion)
|
||||
KnowledgeQA(ctx context.Context,
|
||||
session *types.Session, query string, knowledgeBaseIDs []string,
|
||||
) ([]*types.SearchResult, <-chan types.StreamResponse, error)
|
||||
session *types.Session, query string, knowledgeBaseIDs []string, assistantMessageID string, eventBus *event.EventBus,
|
||||
) error
|
||||
// KnowledgeQAByEvent performs knowledge-based question answering by event
|
||||
KnowledgeQAByEvent(ctx context.Context, chatManage *types.ChatManage, eventList []types.EventType) error
|
||||
// SearchKnowledge performs knowledge-based search, without summarization
|
||||
SearchKnowledge(ctx context.Context, knowledgeBaseID, query string) ([]*types.SearchResult, error)
|
||||
// AgentQA performs agent-based question answering with conversation history and streaming support
|
||||
// eventBus is optional - if nil, uses service's default EventBus
|
||||
AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) ([]*types.SearchResult, error)
|
||||
AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) error
|
||||
// ClearContext clears the LLM context for a session
|
||||
ClearContext(ctx context.Context, sessionID string) error
|
||||
}
|
||||
|
||||
@@ -9,43 +9,24 @@ import (
|
||||
|
||||
// StreamEvent represents a single event in the stream
|
||||
type StreamEvent struct {
|
||||
ID string `json:"id"` // Unique event ID for precise replacement
|
||||
Type types.ResponseType `json:"type"` // Event type (thinking, tool_call, tool_result, etc.)
|
||||
Content string `json:"content"` // Event content
|
||||
ID string `json:"id"` // Unique event ID
|
||||
Type types.ResponseType `json:"type"` // Event type (thinking, tool_call, tool_result, references, complete, etc.)
|
||||
Content string `json:"content"` // Event content (chunk for streaming events)
|
||||
Done bool `json:"done"` // Whether this event is done
|
||||
Timestamp time.Time `json:"timestamp"` // When this event occurred
|
||||
Data map[string]interface{} `json:"data,omitempty"` // Additional event data
|
||||
Data map[string]interface{} `json:"data,omitempty"` // Additional event data (references, metadata, etc.)
|
||||
}
|
||||
|
||||
// StreamInfo stream information
|
||||
type StreamInfo struct {
|
||||
SessionID string // session ID
|
||||
RequestID string // request ID
|
||||
Query string // query content
|
||||
Events []StreamEvent // all events in order (for replay on refresh)
|
||||
KnowledgeReferences types.References // knowledge references
|
||||
LastUpdated time.Time // last updated time
|
||||
IsCompleted bool // whether completed
|
||||
}
|
||||
|
||||
// StreamManager stream manager interface
|
||||
// StreamManager stream manager interface - minimal append-only design
|
||||
// All stream state is managed through events: metadata, references, completion, etc.
|
||||
type StreamManager interface {
|
||||
// RegisterStream registers a new stream
|
||||
RegisterStream(ctx context.Context, sessionID, requestID, query string) error
|
||||
// AppendEvent appends a single event to the stream
|
||||
// Uses Redis RPush for O(1) append performance
|
||||
// All event types (thinking, tool_call, references, complete) use this method
|
||||
AppendEvent(ctx context.Context, sessionID, messageID string, event StreamEvent) error
|
||||
|
||||
// PushEvent pushes an event to the stream (append mode)
|
||||
PushEvent(ctx context.Context, sessionID, requestID string, event StreamEvent) error
|
||||
|
||||
// ReplaceEvent replaces an event by ID (for streaming progress updates)
|
||||
// If no matching event exists, it will append the event
|
||||
ReplaceEvent(ctx context.Context, sessionID, requestID string, event StreamEvent) error
|
||||
|
||||
// UpdateReferences updates knowledge references
|
||||
UpdateReferences(ctx context.Context, sessionID, requestID string, references types.References) error
|
||||
|
||||
// CompleteStream completes the stream
|
||||
CompleteStream(ctx context.Context, sessionID, requestID string) error
|
||||
|
||||
// GetStream gets a specific stream (for replay on refresh)
|
||||
GetStream(ctx context.Context, sessionID, requestID string) (*StreamInfo, error)
|
||||
// GetEvents gets events starting from offset
|
||||
// Uses Redis LRange for incremental reads
|
||||
// Returns: events slice, next offset for subsequent reads, error
|
||||
GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]StreamEvent, int, error)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user