1144 lines
37 KiB
TypeScript
1144 lines
37 KiB
TypeScript
import { useState, useCallback, useEffect, useRef, useMemo, type Dispatch, type SetStateAction } from 'react'
|
||
import type {
|
||
Command,
|
||
ChatMessage,
|
||
Topic,
|
||
WsOutbound,
|
||
AssistantResponse,
|
||
ToolCall,
|
||
ToolResult,
|
||
ToolPending,
|
||
SessionEstablished,
|
||
SessionList,
|
||
SessionSummary,
|
||
TopicList,
|
||
TopicSummary,
|
||
TaskMessagesLoaded,
|
||
TaskStarted,
|
||
Attachment,
|
||
MemorySummary,
|
||
MemoryList,
|
||
SkillSummary,
|
||
SkillList,
|
||
TodoItemSummary,
|
||
TodoList,
|
||
SchedulerJobList,
|
||
SchedulerJobSummary,
|
||
SchedulerJobSessionLookup,
|
||
Channel,
|
||
ChannelList,
|
||
StreamDelta,
|
||
StreamEnd,
|
||
WsInbound,
|
||
} from '../types/protocol'
|
||
|
||
// 简化后的层级状态
|
||
interface UseChatReturn {
|
||
// 连接状态
|
||
connectionId: string | null
|
||
isConnected: boolean
|
||
|
||
// 简化的层级状态
|
||
sessions: SessionSummary[]
|
||
selectedSessionId: string | null
|
||
session: SessionSummary | null
|
||
sessionId: string | null
|
||
chatId: string
|
||
topics: Topic[]
|
||
selectedTopic: string | null
|
||
|
||
// 消息
|
||
messages: ChatMessage[]
|
||
isLoading: boolean
|
||
|
||
// 通道状态
|
||
channels: Channel[]
|
||
selectedChannel: string
|
||
isWritable: boolean
|
||
|
||
// 是否只读
|
||
isReadOnly: boolean
|
||
|
||
// 子智能体视图（栈结构，支持面包屑导航）
|
||
subAgentView: SubAgentView | null
|
||
subAgentStack: SubAgentView[]
|
||
|
||
// 方法
|
||
handleMessage: (content: string, attachments?: Attachment[]) => void
|
||
handleCommand: (command: Command) => void
|
||
clearMessages: () => void
|
||
handleServerMessage: (message: WsOutbound) => void
|
||
setSendMessage: (fn: (msg: WsInbound) => boolean) => void
|
||
|
||
// Topic 方法
|
||
selectTopic: (topicId: string) => void
|
||
createTopic: (title?: string) => Command
|
||
switchTopic: (topicId: string) => Command
|
||
deleteTopic: (topicId: string) => Command
|
||
|
||
// 初始化方法
|
||
requestSessionList: () => Command
|
||
requestTopicList: () => Command | null
|
||
topicRefreshTrigger: number
|
||
requestChannelList: () => Command
|
||
selectChannel: (channelId: string) => void
|
||
selectSession: (sessionId: string) => void
|
||
|
||
// 子智能体导航方法
|
||
enterSubAgentView: (taskId: string, description: string, subagentType?: string) => Command
|
||
exitSubAgentView: () => void
|
||
navigateToSubAgentLevel: (index: number) => void
|
||
|
||
// 记忆状态
|
||
memories: MemorySummary[]
|
||
requestMemoryList: () => Command
|
||
createMemory: (namespace: string, key: string, content: string) => Command
|
||
updateMemory: (id: string, content: string) => Command
|
||
deleteMemory: (id: string) => Command
|
||
|
||
// 技能状态
|
||
skills: SkillSummary[]
|
||
requestSkillList: () => Command
|
||
|
||
// Todo 状态
|
||
todos: TodoItemSummary[]
|
||
setTodos: Dispatch<SetStateAction<TodoItemSummary[]>>
|
||
requestTodoList: () => Command
|
||
requestSubAgentTodoList: (subTaskId: string) => Command
|
||
|
||
// 高亮消息 ID（点击待办后滚动到对应消息）
|
||
highlightedMessageId: string | null
|
||
setHighlightedMessageId: Dispatch<SetStateAction<string | null>>
|
||
|
||
// 定时任务状态
|
||
schedulerJobs: SchedulerJobSummary[]
|
||
sidebarTab: 'topics' | 'scheduler'
|
||
setSidebarTab: (tab: 'topics' | 'scheduler') => void
|
||
requestSchedulerJobList: () => Command
|
||
|
||
// 定时任务执行对话查看
|
||
schedulerView: SchedulerJobView | null
|
||
enterSchedulerJobView: (lookup: SchedulerJobSessionLookup, jobId: string, description: string) => Command
|
||
exitSchedulerJobView: () => void
|
||
|
||
// 停止当前 Agent 执行
|
||
handleStop: () => Command
|
||
}
|
||
|
||
interface SubAgentView {
|
||
taskId: string
|
||
description: string
|
||
subagentType: string
|
||
status: string
|
||
summary?: string
|
||
messages: ChatMessage[]
|
||
}
|
||
|
||
interface SchedulerJobView {
|
||
jobId: string
|
||
description: string
|
||
channel: string
|
||
chatId: string
|
||
messages: ChatMessage[]
|
||
}
|
||
|
||
const DEFAULT_CHAT_ID = 'default'
|
||
|
||
export function useChat(): UseChatReturn {
|
||
const [messages, setMessages] = useState<ChatMessage[]>([])
|
||
const [isLoading, setIsLoading] = useState(false)
|
||
|
||
// 简化的状态管理
|
||
const [connectionId, setConnectionId] = useState<string | null>(null)
|
||
const [topics, setTopics] = useState<Topic[]>([])
|
||
const [selectedTopic, setSelectedTopic] = useState<string | null>(null)
|
||
const [topicRefreshTrigger, setTopicRefreshTrigger] = useState(0)
|
||
const [sessions, setSessions] = useState<SessionSummary[]>([])
|
||
const [selectedSessionId, setSelectedSessionId] = useState<string | null>(null)
|
||
const [subAgentStack, setSubAgentStack] = useState<SubAgentView[]>([])
|
||
const subAgentView = useMemo(() => subAgentStack.length > 0 ? subAgentStack[subAgentStack.length - 1] : null, [subAgentStack])
|
||
const [memories, setMemories] = useState<MemorySummary[]>([])
|
||
const [skills, setSkills] = useState<SkillSummary[]>([])
|
||
const [todos, setTodos] = useState<TodoItemSummary[]>([])
|
||
const [highlightedMessageId, setHighlightedMessageId] = useState<string | null>(null)
|
||
const [schedulerJobs, setSchedulerJobs] = useState<SchedulerJobSummary[]>([])
|
||
const [sidebarTab, setSidebarTab] = useState<'topics' | 'scheduler'>('topics')
|
||
const [schedulerView, setSchedulerView] = useState<SchedulerJobView | null>(null)
|
||
const [channels, setChannels] = useState<Channel[]>([])
|
||
const [selectedChannel, setSelectedChannel] = useState<string>('websocket')
|
||
|
||
// Track user message IDs already synced from backend to avoid duplicate updates
|
||
const syncedUserMessageIdsRef = useRef<Set<string>>(new Set())
|
||
|
||
// Message ID generator
|
||
const messageIdCounter = useRef(0)
|
||
const generateMessageId = () => {
|
||
messageIdCounter.current += 1
|
||
return `msg_${Date.now()}_${messageIdCounter.current}`
|
||
}
|
||
|
||
// Ref to track subAgentView and schedulerView for use in callbacks
|
||
const subAgentViewRef = useRef<SubAgentView | null>(null)
|
||
const schedulerViewRef = useRef<SchedulerJobView | null>(null)
|
||
const topicsRef = useRef<Topic[]>([])
|
||
const selectedTopicRef = useRef<string | null>(null)
|
||
const pendingNewTopicRef = useRef(false)
|
||
|
||
// Pending task navigations: tool_call_id -> task_id
|
||
// Used when task_started arrives before the tool_call is in the sub-agent view
|
||
const pendingTaskNavsRef = useRef<Map<string, string>>(new Map())
|
||
|
||
// Ref to send commands from within handleServerMessage (set by App.tsx)
|
||
const sendMessageRef = useRef<((msg: WsInbound) => boolean) | null>(null)
|
||
const setSendMessage = useCallback((fn: (msg: WsInbound) => boolean) => {
|
||
sendMessageRef.current = fn
|
||
}, [])
|
||
|
||
const isConnected = useMemo(() => connectionId !== null, [connectionId])
|
||
const selectedSession = useMemo(
|
||
() => sessions.find(s => s.session_id === selectedSessionId) ?? null,
|
||
[sessions, selectedSessionId]
|
||
)
|
||
const sessionId = useMemo(() => selectedSession?.session_id ?? null, [selectedSession])
|
||
const chatId = useMemo(() => sessionId ?? DEFAULT_CHAT_ID, [sessionId])
|
||
const isWritable = useMemo(
|
||
() => channels.find(c => c.id === selectedChannel)?.isWritable ?? false,
|
||
[channels, selectedChannel]
|
||
)
|
||
|
||
// Extract subagent_task_id from a message if present
|
||
const getSubagentTaskId = (message: WsOutbound): string | undefined => {
|
||
if (message.type === 'tool_call' || message.type === 'tool_result'
|
||
|| message.type === 'tool_pending' || message.type === 'assistant_response') {
|
||
return (message as ToolCall | ToolResult | ToolPending | AssistantResponse).subagent_task_id
|
||
}
|
||
if (message.type === 'stream_delta' || message.type === 'stream_end') {
|
||
return (message as StreamDelta | StreamEnd).subagent_task_id
|
||
}
|
||
return undefined
|
||
}
|
||
|
||
// Convert a server message to ChatMessage (extracted from handleServerMessage logic)
|
||
const serverMessageToChatMessage = (message: WsOutbound): ChatMessage | null => {
|
||
switch (message.type) {
|
||
case 'assistant_response': {
|
||
const msg = message as AssistantResponse
|
||
const role = msg.role === 'user' || msg.role === 'tool' ? msg.role : 'assistant'
|
||
return {
|
||
id: msg.id,
|
||
role: role as ChatMessage['role'],
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
attachments: msg.attachments,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
reasoningContent: msg.reasoning_content,
|
||
}
|
||
}
|
||
case 'tool_call': {
|
||
const msg = message as ToolCall
|
||
return {
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_call',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
arguments: msg.arguments,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
reasoningContent: msg.reasoning_content,
|
||
}
|
||
}
|
||
case 'tool_result': {
|
||
const msg = message as ToolResult
|
||
return {
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_result',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
durationMs: msg.duration_ms,
|
||
}
|
||
}
|
||
case 'tool_pending': {
|
||
const msg = message as ToolPending
|
||
return {
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: `${msg.content}\n\n${msg.resume_hint}`,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_pending',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
}
|
||
}
|
||
case 'stream_delta': {
|
||
const msg = message as StreamDelta
|
||
return {
|
||
id: msg.id,
|
||
role: 'assistant' as const,
|
||
content: msg.delta,
|
||
timestamp: Math.floor(Date.now() / 1000),
|
||
type: 'message' as const,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
reasoningContent: msg.reasoning_delta,
|
||
}
|
||
}
|
||
case 'error': {
|
||
return {
|
||
id: generateMessageId(),
|
||
role: 'assistant',
|
||
content: `Error: ${message.message}`,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
}
|
||
}
|
||
default:
|
||
return null
|
||
}
|
||
}
|
||
|
||
// Append a server message to the sub-agent view (with streaming delta accumulation)
|
||
const appendToSubAgentViewMessage = (message: WsOutbound) => {
|
||
// stream_delta: accumulate into existing message by ID, or create new
|
||
if (message.type === 'stream_delta') {
|
||
const msg = message as StreamDelta
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length === 0) return prev
|
||
const top = prev[prev.length - 1]
|
||
const existingIdx = top.messages.findIndex(m => m.id === msg.id && m.type === 'message')
|
||
if (existingIdx >= 0) {
|
||
const updated = [...top.messages]
|
||
const existing = updated[existingIdx]
|
||
updated[existingIdx] = {
|
||
...existing,
|
||
content: existing.content + msg.delta,
|
||
reasoningContent: msg.reasoning_delta
|
||
? (existing.reasoningContent || '') + msg.reasoning_delta
|
||
: existing.reasoningContent,
|
||
}
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: updated }
|
||
return newStack
|
||
}
|
||
const chatMsg = serverMessageToChatMessage(message)
|
||
if (!chatMsg) return prev
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: [...top.messages, chatMsg] }
|
||
return newStack
|
||
})
|
||
return
|
||
}
|
||
// stream_end: no-op, assistant_response will replace
|
||
if (message.type === 'stream_end') return
|
||
// Other messages: assistant_response replaces streamed message by ID
|
||
const chatMsg = serverMessageToChatMessage(message)
|
||
if (chatMsg) {
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length === 0) return prev
|
||
const top = prev[prev.length - 1]
|
||
if (message.type === 'assistant_response') {
|
||
const existingIdx = top.messages.findIndex(m => m.id === chatMsg.id && m.type === 'message')
|
||
if (existingIdx >= 0) {
|
||
const updated = [...top.messages]
|
||
updated[existingIdx] = chatMsg
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: updated }
|
||
return newStack
|
||
}
|
||
}
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: [...top.messages, chatMsg] }
|
||
return newStack
|
||
})
|
||
}
|
||
}
|
||
|
||
// Sync backend user message ID to the last local user message,
|
||
// so that created_by_message_id (backend UUID) can match DOM data-message-id
|
||
const applyUserMessageId = useCallback((userMessageId: string) => {
|
||
if (syncedUserMessageIdsRef.current.has(userMessageId)) return
|
||
syncedUserMessageIdsRef.current.add(userMessageId)
|
||
setMessages(prev => {
|
||
for (let i = prev.length - 1; i >= 0; i--) {
|
||
if (prev[i].role === 'user') {
|
||
const updated = [...prev]
|
||
updated[i] = { ...updated[i], id: userMessageId }
|
||
return updated
|
||
}
|
||
}
|
||
return prev
|
||
})
|
||
}, [])
|
||
|
||
const handleServerMessage = useCallback((message: WsOutbound) => {
|
||
console.log('Received message:', message)
|
||
|
||
// Route to scheduler job view if active
|
||
const currentSchedulerView = schedulerViewRef.current
|
||
if (currentSchedulerView) {
|
||
// Route chat messages to the scheduler view
|
||
const chatMsg = serverMessageToChatMessage(message)
|
||
if (chatMsg) {
|
||
setSchedulerView((prev) =>
|
||
prev
|
||
? { ...prev, messages: [...prev.messages, chatMsg] }
|
||
: prev
|
||
)
|
||
return
|
||
}
|
||
// Non-chat messages (session_list, topic_list, etc.) fall through to main handler
|
||
}
|
||
|
||
// Route to sub-agent view if active
|
||
const currentSubAgentView = subAgentViewRef.current
|
||
if (currentSubAgentView) {
|
||
if (message.type === 'task_messages_loaded') {
|
||
const msg = message as TaskMessagesLoaded
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length === 0) return prev
|
||
const top = prev[prev.length - 1]
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = {
|
||
...top,
|
||
subagentType: msg.subagent_type,
|
||
status: msg.status,
|
||
summary: msg.summary,
|
||
}
|
||
return newStack
|
||
})
|
||
return
|
||
}
|
||
|
||
// When the sub-agent spawns a grandchild, set navigateToTaskId
|
||
// on the task tool_call so "查看实时进度" navigates correctly.
|
||
if (message.type === 'task_started') {
|
||
const msg = message as TaskStarted
|
||
if (msg.parent_task_id === currentSubAgentView.taskId) {
|
||
let matched = false
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length === 0) return prev
|
||
const top = prev[prev.length - 1]
|
||
const updatedMessages = [...top.messages]
|
||
|
||
// 优先：按 tool_call_id 精确匹配
|
||
if (msg.tool_call_id) {
|
||
const idx = updatedMessages.findIndex(m =>
|
||
m.toolCallId === msg.tool_call_id && m.type === 'tool_call' && m.toolName === 'task')
|
||
if (idx >= 0 && !updatedMessages[idx].navigateToTaskId) {
|
||
updatedMessages[idx] = { ...updatedMessages[idx], navigateToTaskId: msg.task_id }
|
||
matched = true
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: updatedMessages }
|
||
return newStack
|
||
}
|
||
}
|
||
// 回退：backward-search (兼容无 tool_call_id 的旧版本)
|
||
for (let i = updatedMessages.length - 1; i >= 0; i--) {
|
||
const m = updatedMessages[i]
|
||
if (m.type === 'tool_call' && m.toolName === 'task' && !m.navigateToTaskId) {
|
||
updatedMessages[i] = { ...m, navigateToTaskId: msg.task_id }
|
||
matched = true
|
||
break
|
||
}
|
||
}
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: updatedMessages }
|
||
return newStack
|
||
})
|
||
if (!matched) {
|
||
// tool_call 尚未到达，存储 pending navigation 等后续 tool_call 到达时回填
|
||
const key = msg.tool_call_id || `fallback:${msg.task_id}`
|
||
pendingTaskNavsRef.current.set(key, msg.task_id)
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// Only accept messages explicitly tagged with matching subagent_task_id.
|
||
// History messages are now tagged by the backend (send_task_messages),
|
||
// and live sub-agent messages are tagged by SubAgentEmitter.
|
||
const msgSubagentTaskId = getSubagentTaskId(message)
|
||
if (msgSubagentTaskId && msgSubagentTaskId === currentSubAgentView.taskId) {
|
||
appendToSubAgentViewMessage(message)
|
||
|
||
// 检查 pending navigation：当 task tool_call 到达时，回填之前未匹配的 navigateToTaskId
|
||
if (message.type === 'tool_call') {
|
||
const tc = message as ToolCall
|
||
if (tc.tool_name === 'task' && tc.tool_call_id) {
|
||
const key = tc.tool_call_id
|
||
const pendingTaskId = pendingTaskNavsRef.current.get(key)
|
||
if (pendingTaskId) {
|
||
pendingTaskNavsRef.current.delete(key)
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length === 0) return prev
|
||
const top = prev[prev.length - 1]
|
||
const updatedMessages = [...top.messages]
|
||
const idx = updatedMessages.findIndex(m =>
|
||
m.toolCallId === tc.tool_call_id && m.type === 'tool_call')
|
||
if (idx >= 0) {
|
||
updatedMessages[idx] = { ...updatedMessages[idx], navigateToTaskId: pendingTaskId }
|
||
const newStack = [...prev]
|
||
newStack[newStack.length - 1] = { ...top, messages: updatedMessages }
|
||
return newStack
|
||
}
|
||
return prev
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
// 子代理 todo_write 完成后自动刷新待办列表
|
||
if (message.type === 'tool_result' && (message as ToolResult).tool_name === 'todo_write') {
|
||
const refreshCmd = requestSubAgentTodoList(currentSubAgentView.taskId)
|
||
sendMessageRef.current?.({ type: 'command', payload: JSON.stringify(refreshCmd) })
|
||
}
|
||
return
|
||
}
|
||
// 丢弃其他子智能体的消息，避免 fall through 到主消息处理
|
||
if (msgSubagentTaskId) {
|
||
return
|
||
}
|
||
}
|
||
|
||
// In main view, skip sub-agent messages (they belong to sub-agent view).
|
||
const msgSubagentTaskId = getSubagentTaskId(message)
|
||
if (msgSubagentTaskId) {
|
||
return
|
||
}
|
||
|
||
switch (message.type) {
|
||
case 'session_established': {
|
||
const msg = message as SessionEstablished
|
||
setConnectionId(msg.session_id)
|
||
console.log('Connection established:', msg.session_id)
|
||
break
|
||
}
|
||
|
||
case 'task_started': {
|
||
const msg = message as TaskStarted
|
||
console.log('[useChat] task_started received:', { task_id: msg.task_id, topic_id: msg.topic_id, parent_task_id: msg.parent_task_id, selectedTopic: selectedTopicRef.current })
|
||
// 只 backfill 当前话题的 task tool_call，避免跨话题串扰
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) {
|
||
console.log('[useChat] task_started filtered by topic_id')
|
||
break
|
||
}
|
||
// 孙智能体的 TaskStarted 不应 backfill 到主视图
|
||
if (msg.parent_task_id) {
|
||
console.log('[useChat] task_started filtered by parent_task_id')
|
||
break
|
||
}
|
||
|
||
// 设置 navigateToTaskId，让用户可以点击查看实时进度
|
||
setMessages((prev) => {
|
||
console.log('[useChat] task_started searching messages for task tool_call, total messages:', prev.length, 'tool_call_id:', msg.tool_call_id)
|
||
// 优先：按 tool_call_id 精确匹配
|
||
if (msg.tool_call_id) {
|
||
const idx = prev.findIndex(m =>
|
||
m.toolCallId === msg.tool_call_id && m.type === 'tool_call' && m.toolName === 'task')
|
||
if (idx >= 0 && !prev[idx].navigateToTaskId) {
|
||
console.log('[useChat] task_started EXACT MATCH at index', idx, 'task_id:', msg.task_id)
|
||
const updated = [...prev]
|
||
updated[idx] = { ...updated[idx], navigateToTaskId: msg.task_id }
|
||
return updated
|
||
}
|
||
}
|
||
// 回退：backward-search (兼容无 tool_call_id 的旧版本)
|
||
for (let i = prev.length - 1; i >= 0; i--) {
|
||
if (prev[i].type === 'tool_call' && prev[i].toolName === 'task' && !prev[i].navigateToTaskId) {
|
||
console.log('[useChat] task_started BACKWARD MATCH at index', i, 'task_id:', msg.task_id)
|
||
const updated = [...prev]
|
||
updated[i] = { ...updated[i], navigateToTaskId: msg.task_id }
|
||
return updated
|
||
}
|
||
}
|
||
console.log('[useChat] task_started NO matching task tool_call found in messages')
|
||
return prev
|
||
})
|
||
break
|
||
}
|
||
|
||
case 'session_list': {
|
||
const msg = message as SessionList
|
||
console.log('Session list received:', msg)
|
||
|
||
// 清空旧数据（切换通道时避免数据污染）
|
||
setTopics([])
|
||
setSelectedTopic(null)
|
||
setMessages([])
|
||
|
||
// 存储全部 session
|
||
setSessions(msg.sessions)
|
||
|
||
// 自动选中：优先保持当前选中，否则选第一个
|
||
setSelectedSessionId(prev => {
|
||
if (prev && msg.sessions.some(s => s.session_id === prev)) {
|
||
return prev
|
||
}
|
||
return msg.sessions.length > 0 ? msg.sessions[0].session_id : null
|
||
})
|
||
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'session_created': {
|
||
// 创建新 Topic 后更新列表
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'session_loaded': {
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'topic_list': {
|
||
const msg = message as TopicList
|
||
console.log('Topic list received:', msg)
|
||
|
||
// 转换 topics 格式
|
||
const newTopics: Topic[] = msg.topics.map((t: TopicSummary) => ({
|
||
id: t.topic_id,
|
||
session_id: t.session_id,
|
||
title: t.title,
|
||
description: t.description || undefined,
|
||
message_count: Number(t.message_count),
|
||
created_at: t.created_at,
|
||
updated_at: t.last_active_at,
|
||
}))
|
||
setTopics(newTopics)
|
||
|
||
// 新建话题后自动聚焦到新话题（列表按 last_active_at DESC 排序，第一个即最新）
|
||
if (pendingNewTopicRef.current) {
|
||
pendingNewTopicRef.current = false
|
||
if (newTopics.length > 0) {
|
||
setSelectedTopic(newTopics[0].id)
|
||
setMessages([])
|
||
}
|
||
}
|
||
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'stream_delta': {
|
||
const msg = message as StreamDelta
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) return
|
||
setMessages((prev) => {
|
||
const existingIdx = prev.findIndex(m => m.id === msg.id && m.type === 'message')
|
||
if (existingIdx >= 0) {
|
||
// 追加到已有消息
|
||
const updated = [...prev]
|
||
const existing = updated[existingIdx]
|
||
updated[existingIdx] = {
|
||
...existing,
|
||
content: existing.content + msg.delta,
|
||
reasoningContent: msg.reasoning_delta
|
||
? (existing.reasoningContent || '') + msg.reasoning_delta
|
||
: existing.reasoningContent,
|
||
}
|
||
return updated
|
||
}
|
||
// 创建新消息
|
||
return [
|
||
...prev,
|
||
{
|
||
id: msg.id,
|
||
role: 'assistant' as const,
|
||
content: msg.delta,
|
||
timestamp: Math.floor(Date.now() / 1000),
|
||
type: 'message' as const,
|
||
reasoningContent: msg.reasoning_delta,
|
||
},
|
||
]
|
||
})
|
||
setIsLoading(false)
|
||
if (msg.user_message_id) applyUserMessageId(msg.user_message_id)
|
||
break
|
||
}
|
||
|
||
case 'stream_end': {
|
||
// 流式结束，无需额外操作，后续 assistant_response 会替换完整内容
|
||
break
|
||
}
|
||
|
||
case 'assistant_response': {
|
||
const msg = message as AssistantResponse
|
||
// 按 topic_id 隔离：如果消息属于其他话题则丢弃
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) return
|
||
const role = msg.role === 'user' || msg.role === 'tool' ? msg.role : 'assistant'
|
||
setMessages((prev) => {
|
||
// 如果流式消息已存在（相同 id），替换它
|
||
const existingIdx = prev.findIndex(m => m.id === msg.id && m.type === 'message')
|
||
const newMsg: ChatMessage = {
|
||
id: msg.id,
|
||
role,
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
attachments: msg.attachments,
|
||
reasoningContent: msg.reasoning_content,
|
||
}
|
||
if (existingIdx >= 0) {
|
||
const updated = [...prev]
|
||
updated[existingIdx] = newMsg
|
||
return updated
|
||
}
|
||
return [...prev, newMsg]
|
||
})
|
||
setIsLoading(false)
|
||
|
||
// 当前话题无描述时，可能刚触发了异步生成，标记需要刷新
|
||
const currentTopic = topicsRef.current.find(t => t.id === selectedTopicRef.current)
|
||
if (currentTopic && !currentTopic.description) {
|
||
setTopicRefreshTrigger(n => n + 1)
|
||
}
|
||
if (msg.user_message_id) applyUserMessageId(msg.user_message_id)
|
||
break
|
||
}
|
||
|
||
case 'tool_call': {
|
||
const msg = message as ToolCall
|
||
// 按 topic_id 隔离：如果消息属于其他话题则丢弃
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) return
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_call',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
arguments: msg.arguments,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
reasoningContent: msg.reasoning_content,
|
||
},
|
||
])
|
||
if (msg.user_message_id) applyUserMessageId(msg.user_message_id)
|
||
break
|
||
}
|
||
|
||
case 'tool_result': {
|
||
const msg = message as ToolResult
|
||
// 按 topic_id 隔离：如果消息属于其他话题则丢弃
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) return
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: msg.content,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_result',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
subagentTaskId: msg.subagent_task_id,
|
||
durationMs: msg.duration_ms,
|
||
},
|
||
])
|
||
break
|
||
}
|
||
|
||
case 'tool_pending': {
|
||
const msg = message as ToolPending
|
||
// 按 topic_id 隔离：如果消息属于其他话题则丢弃
|
||
if (msg.topic_id && msg.topic_id !== selectedTopicRef.current) return
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: msg.id,
|
||
role: 'tool',
|
||
content: `${msg.content}\n\n${msg.resume_hint}`,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'tool_pending',
|
||
toolName: msg.tool_name,
|
||
toolCallId: msg.tool_call_id,
|
||
},
|
||
])
|
||
break
|
||
}
|
||
|
||
case 'execution_cancelled': {
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: generateMessageId(),
|
||
role: 'assistant',
|
||
content: (message as { type: 'execution_cancelled'; message: string }).message,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
},
|
||
])
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'error': {
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: generateMessageId(),
|
||
role: 'assistant',
|
||
content: `Error: ${message.message}`,
|
||
timestamp: (message as any).timestamp ?? Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
},
|
||
])
|
||
setIsLoading(false)
|
||
break
|
||
}
|
||
|
||
case 'scheduler_job_list': {
|
||
const msg = message as SchedulerJobList
|
||
setSchedulerJobs(msg.jobs)
|
||
break
|
||
}
|
||
case 'memory_list': {
|
||
const msg = message as MemoryList
|
||
setMemories(msg.memories)
|
||
break
|
||
}
|
||
case 'skill_list': {
|
||
const msg = message as SkillList
|
||
setSkills(msg.skills)
|
||
break
|
||
}
|
||
case 'todo_list': {
|
||
const msg = message as TodoList
|
||
setTodos(msg.todos)
|
||
break
|
||
}
|
||
|
||
case 'channel_list': {
|
||
const msg = message as ChannelList
|
||
console.log('Channel list received:', msg)
|
||
setChannels(msg.channels)
|
||
break
|
||
}
|
||
case 'pong':
|
||
// 忽略这些消息
|
||
break
|
||
}
|
||
|
||
// 主视图 todo_write 完成后自动刷新待办列表
|
||
if (message.type === 'tool_result' && (message as ToolResult).tool_name === 'todo_write') {
|
||
const refreshCmd = subAgentViewRef.current?.taskId
|
||
? requestSubAgentTodoList(subAgentViewRef.current.taskId)
|
||
: requestTodoList()
|
||
sendMessageRef.current?.({ type: 'command', payload: JSON.stringify(refreshCmd) })
|
||
}
|
||
}, [])
|
||
|
||
const handleMessage = useCallback((content: string, attachments?: Attachment[]) => {
|
||
setMessages((prev) => [
|
||
...prev,
|
||
{
|
||
id: generateMessageId(),
|
||
role: 'user',
|
||
content,
|
||
timestamp: Math.floor(Date.now() / 1000),
|
||
type: 'message',
|
||
attachments: attachments || [],
|
||
},
|
||
])
|
||
setIsLoading(true)
|
||
}, [])
|
||
|
||
const handleCommand = useCallback((command: Command) => {
|
||
switch (command.type) {
|
||
case 'create_session':
|
||
case 'switch_topic':
|
||
case 'load_topic':
|
||
case 'list_sessions':
|
||
case 'list_sessions_by_channel':
|
||
case 'delete_topic':
|
||
case 'list_topics':
|
||
setIsLoading(true)
|
||
break
|
||
}
|
||
}, [])
|
||
|
||
const clearMessages = useCallback(() => {
|
||
setMessages([])
|
||
}, [])
|
||
|
||
// Topic 操作方法
|
||
const selectTopic = useCallback((topicId: string) => {
|
||
setSelectedTopic(topicId)
|
||
setMessages([])
|
||
setSubAgentStack([])
|
||
}, [])
|
||
|
||
const createTopic = useCallback((title?: string): Command => {
|
||
pendingNewTopicRef.current = true
|
||
return {
|
||
type: 'create_session',
|
||
title: title || `话题 ${new Date().toLocaleString('zh-CN', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })}`,
|
||
}
|
||
}, [])
|
||
|
||
const switchTopic = useCallback((topicId: string): Command => {
|
||
return {
|
||
type: 'switch_topic',
|
||
topic_id: topicId,
|
||
}
|
||
}, [])
|
||
|
||
const deleteTopic = useCallback((topicId: string): Command => {
|
||
return {
|
||
type: 'delete_topic',
|
||
topic_id: topicId,
|
||
}
|
||
}, [])
|
||
|
||
// 初始化方法
|
||
const requestSessionList = useCallback((): Command => {
|
||
return {
|
||
type: 'list_sessions_by_channel',
|
||
channel_name: selectedChannel,
|
||
include_archived: false,
|
||
}
|
||
}, [selectedChannel])
|
||
|
||
const requestChannelList = useCallback((): Command => {
|
||
return { type: 'list_channels' }
|
||
}, [])
|
||
|
||
const selectChannel = useCallback((channelId: string) => {
|
||
if (channelId === selectedChannel) return
|
||
setSelectedChannel(channelId)
|
||
setSessions([])
|
||
setSelectedSessionId(null)
|
||
setTopics([])
|
||
setSelectedTopic(null)
|
||
setMessages([])
|
||
setSubAgentStack([])
|
||
setIsLoading(true)
|
||
}, [selectedChannel])
|
||
|
||
const selectSession = useCallback((sessionId: string) => {
|
||
if (sessionId === selectedSessionId) return
|
||
setSelectedSessionId(sessionId)
|
||
setTopics([])
|
||
setSelectedTopic(null)
|
||
setMessages([])
|
||
setSubAgentStack([])
|
||
setIsLoading(true)
|
||
}, [selectedSessionId])
|
||
|
||
const requestTopicList = useCallback((): Command | null => {
|
||
if (!sessionId) return null
|
||
return {
|
||
type: 'list_topics',
|
||
session_id: sessionId,
|
||
}
|
||
}, [sessionId])
|
||
|
||
// Keep refs in sync with state
|
||
useEffect(() => {
|
||
subAgentViewRef.current = subAgentView
|
||
}, [subAgentView])
|
||
|
||
useEffect(() => {
|
||
schedulerViewRef.current = schedulerView
|
||
}, [schedulerView])
|
||
|
||
useEffect(() => {
|
||
topicsRef.current = topics
|
||
}, [topics])
|
||
|
||
useEffect(() => {
|
||
selectedTopicRef.current = selectedTopic
|
||
}, [selectedTopic])
|
||
|
||
const enterSubAgentView = useCallback((taskId: string, description: string, subagentType?: string): Command => {
|
||
const newView: SubAgentView = {
|
||
taskId,
|
||
description,
|
||
subagentType: subagentType || '',
|
||
status: 'loading',
|
||
messages: [],
|
||
}
|
||
setSubAgentStack((prev) => {
|
||
const newStack = [...prev, newView]
|
||
// Sync ref immediately so WebSocket response routing works correctly
|
||
subAgentViewRef.current = newView
|
||
return newStack
|
||
})
|
||
return {
|
||
type: 'load_task_messages',
|
||
task_id: taskId,
|
||
}
|
||
}, [])
|
||
|
||
const exitSubAgentView = useCallback(() => {
|
||
setSubAgentStack((prev) => {
|
||
if (prev.length <= 1) {
|
||
subAgentViewRef.current = null
|
||
return []
|
||
}
|
||
const newStack = prev.slice(0, -1)
|
||
subAgentViewRef.current = newStack[newStack.length - 1]
|
||
return newStack
|
||
})
|
||
}, [])
|
||
|
||
const navigateToSubAgentLevel = useCallback((index: number) => {
|
||
setSubAgentStack((prev) => {
|
||
if (index < 0) {
|
||
// -1 means go back to main session (clear all)
|
||
subAgentViewRef.current = null
|
||
return []
|
||
}
|
||
if (index >= prev.length) return prev
|
||
const newStack = prev.slice(0, index + 1)
|
||
subAgentViewRef.current = newStack.length > 0 ? newStack[newStack.length - 1] : null
|
||
return newStack
|
||
})
|
||
}, [])
|
||
|
||
// 记忆方法
|
||
const requestMemoryList = useCallback((): Command => {
|
||
return { type: 'list_memories' }
|
||
}, [])
|
||
|
||
const createMemory = useCallback((namespace: string, key: string, content: string): Command => {
|
||
return { type: 'create_memory', namespace, key, content }
|
||
}, [])
|
||
|
||
const updateMemory = useCallback((id: string, content: string): Command => {
|
||
return { type: 'update_memory', id, content }
|
||
}, [])
|
||
|
||
const deleteMemory = useCallback((id: string): Command => {
|
||
return { type: 'delete_memory', id }
|
||
}, [])
|
||
|
||
const requestSkillList = useCallback((): Command => {
|
||
return { type: 'list_skills' }
|
||
}, [])
|
||
|
||
const requestTodoList = useCallback((): Command => {
|
||
return { type: 'list_todos' }
|
||
}, [])
|
||
|
||
const requestSubAgentTodoList = useCallback((subTaskId: string): Command => {
|
||
return { type: 'list_todos', task_id: subTaskId }
|
||
}, [])
|
||
|
||
// 定时任务方法
|
||
const requestSchedulerJobList = useCallback((): Command => {
|
||
return { type: 'list_scheduler_jobs' }
|
||
}, [])
|
||
|
||
const enterSchedulerJobView = useCallback(
|
||
(lookup: SchedulerJobSessionLookup, jobId: string, description: string): Command => {
|
||
const newView: SchedulerJobView = {
|
||
jobId,
|
||
description,
|
||
channel: lookup.channel,
|
||
chatId: lookup.chat_id,
|
||
messages: [],
|
||
}
|
||
schedulerViewRef.current = newView
|
||
setSchedulerView(newView)
|
||
return {
|
||
type: 'load_chat_messages',
|
||
channel: lookup.channel,
|
||
chat_id: lookup.chat_id,
|
||
}
|
||
},
|
||
[]
|
||
)
|
||
|
||
const exitSchedulerJobView = useCallback(() => {
|
||
schedulerViewRef.current = null
|
||
setSchedulerView(null)
|
||
}, [])
|
||
|
||
const handleStop = useCallback((): Command => {
|
||
return { type: 'stop_execution' }
|
||
}, [])
|
||
|
||
// Memoize messages: sub-agent view > scheduler view > main
|
||
const resolvedMessages = useMemo(() => {
|
||
if (subAgentView) {
|
||
return subAgentView.messages
|
||
}
|
||
if (schedulerView) {
|
||
return schedulerView.messages
|
||
}
|
||
return messages
|
||
}, [subAgentView, schedulerView, messages])
|
||
|
||
// 只读状态由当前通道决定
|
||
const isReadOnly = !isWritable
|
||
|
||
return {
|
||
connectionId,
|
||
isConnected,
|
||
sessions,
|
||
selectedSessionId,
|
||
session: selectedSession,
|
||
sessionId,
|
||
chatId,
|
||
topics,
|
||
selectedTopic,
|
||
messages: resolvedMessages,
|
||
isLoading,
|
||
isReadOnly,
|
||
isWritable,
|
||
channels,
|
||
selectedChannel,
|
||
subAgentView,
|
||
subAgentStack,
|
||
handleMessage,
|
||
handleCommand,
|
||
clearMessages,
|
||
handleServerMessage,
|
||
setSendMessage,
|
||
selectTopic,
|
||
createTopic,
|
||
switchTopic,
|
||
deleteTopic,
|
||
requestSessionList,
|
||
requestTopicList,
|
||
topicRefreshTrigger,
|
||
requestChannelList,
|
||
selectChannel,
|
||
selectSession,
|
||
enterSubAgentView,
|
||
exitSubAgentView,
|
||
navigateToSubAgentLevel,
|
||
memories,
|
||
requestMemoryList,
|
||
createMemory,
|
||
updateMemory,
|
||
deleteMemory,
|
||
skills,
|
||
requestSkillList,
|
||
todos,
|
||
setTodos,
|
||
requestTodoList,
|
||
requestSubAgentTodoList,
|
||
highlightedMessageId,
|
||
setHighlightedMessageId,
|
||
schedulerJobs,
|
||
sidebarTab,
|
||
setSidebarTab,
|
||
requestSchedulerJobList,
|
||
schedulerView,
|
||
enterSchedulerJobView,
|
||
exitSchedulerJobView,
|
||
handleStop,
|
||
}
|
||
}
|