AstrBot-Desktop/src/features/chat/ChatPanel.tsx

1019 行
31 KiB
TypeScript

import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { errorMessage } from "../../lib/errorMessage";
2026-07-21 15:25:11 +08:00
import { MessageContent } from "./MessageContent";
import {
astrbotAttachmentSchema,
astrbotCapabilitySnapshotSchema,
boundRuntimeEventSchema,
chatSessionSchema,
connectionRuntimeStatusSchema,
type AstrBotAttachment,
type AstrBotCapabilitySnapshot,
type BoundRuntimeEvent,
type ChatSession,
mergeLoadedChatMessages,
remoteChatSessionSchema,
type ChatMessage,
type ChatSlot,
type RemoteChatSession,
type ConnectionRuntimeStatus,
storedChatMessageSchema,
slotRuntimeSnapshotSchema,
} from "./types";
const emptyStatus: ConnectionRuntimeStatus = {
companion: { slot: "companion", state: "disconnected" },
operations: { slot: "operations", state: "disconnected" },
};
function payloadString(
event: BoundRuntimeEvent,
key: string,
): string | undefined {
if (!event.payload || typeof event.payload !== "object") return undefined;
const value = (event.payload as Record<string, unknown>)[key];
return typeof value === "string" ? value : undefined;
}
export interface ChatPanelProps {
fixedSlot?: ChatSlot;
}
type SpeechRecognitionLike = {
lang: string;
interimResults: boolean;
onresult: ((event: unknown) => void) | null;
onerror: (() => void) | null;
onend: (() => void) | null;
start: () => void;
stop: () => void;
};
export function ChatPanel({ fixedSlot }: ChatPanelProps) {
const [status, setStatus] = useState(emptyStatus);
const [messages, setMessages] = useState<ChatMessage[]>([]);
const [remoteSessions, setRemoteSessions] = useState<RemoteChatSession[]>([]);
const [storedSessions, setStoredSessions] = useState<
Record<ChatSlot, ChatSession[]>
>({
companion: [],
operations: [],
});
const [activeSlot, setActiveSlot] = useState<ChatSlot>(
fixedSlot ?? "companion",
);
const selectedSlot = fixedSlot ?? activeSlot;
const selectedSnapshot = status[selectedSlot];
const selectedProfileId = selectedSnapshot.profileId;
const selectedServerInstanceId = selectedSnapshot.serverInstanceId;
const selectedSessionId = selectedSnapshot.activeSessionId;
const historySessionId =
selectedSessionId ?? storedSessions[selectedSlot][0]?.sessionId;
const selectedTransport = selectedSnapshot.transport;
const [draft, setDraft] = useState("");
const [error, setError] = useState<string | null>(null);
const [capabilities, setCapabilities] =
useState<AstrBotCapabilitySnapshot | null>(null);
const [pendingAttachments, setPendingAttachments] = useState<
AstrBotAttachment[]
>([]);
const [uploading, setUploading] = useState(false);
const [voiceListening, setVoiceListening] = useState(false);
2026-07-21 15:25:11 +08:00
const [sending, setSending] = useState<Record<ChatSlot, boolean>>({
companion: false,
operations: false,
});
const speechRecognition = useRef<{
start: () => void;
stop: () => void;
} | null>(null);
const [unreadCounts, setUnreadCounts] = useState<Record<ChatSlot, number>>({
companion: 0,
operations: 0,
});
const activeMessages = useMemo(
() =>
messages.filter(
(item) =>
item.slot === selectedSlot &&
(!status[selectedSlot].activeSessionId ||
item.sessionId === status[selectedSlot].activeSessionId),
),
[messages, selectedSlot, status],
);
const visibleMessages = useMemo(
() =>
activeMessages.filter(
2026-07-21 15:25:11 +08:00
(message) =>
message.content.trim().length > 0 ||
message.streaming ||
message.error,
),
[activeMessages],
);
const displaySessions =
remoteSessions.length > 0
? remoteSessions
: storedSessions[selectedSlot].map((session) => ({
sessionId: session.sessionId,
displayName: undefined,
updatedAt: session.lastMessageAt,
}));
const refresh = useCallback(async () => {
try {
const result = await invoke<unknown>("connection_runtime_status");
const parsed = connectionRuntimeStatusSchema.safeParse(result);
if (!parsed.success) {
setError("连接状态暂不可用,请检查连接配置。");
return false;
}
setStatus(parsed.data);
setError(null);
return true;
} catch {
setError("连接状态暂不可用,请检查本地运行时。");
return false;
}
}, []);
useEffect(() => {
let unlisten: (() => void) | undefined;
void listen<unknown>("connection-runtime-event", (event) => {
const parsed = boundRuntimeEventSchema.safeParse(event.payload);
if (parsed.success) {
setMessages((current) => applyRuntimeEvents(current, [parsed.data]));
}
}).then((cleanup) => {
unlisten = cleanup;
});
return () => unlisten?.();
}, []);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
transport: selectedTransport,
};
if (!snapshot.profileId || !snapshot.serverInstanceId) return;
let cancelled = false;
void invoke<unknown>("list_chat_sessions", {
request: {
profileId: snapshot.profileId,
slot: selectedSlot,
serverInstanceId: snapshot.serverInstanceId,
},
})
.then((result) => {
if (cancelled) return;
const sessions = chatSessionSchema.array().parse(result);
setStoredSessions((current) => ({
...current,
[selectedSlot]: sessions,
}));
setUnreadCounts((current) => ({
...current,
[selectedSlot]: sessions.reduce(
(total, session) => total + session.unreadCount,
0,
),
}));
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
historySessionId,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
transport: selectedTransport,
};
setRemoteSessions([]);
if (!snapshot.profileId) return;
let cancelled = false;
void invoke<unknown>("connection_slot_sessions", {
request: { slot: selectedSlot },
})
.then((result) => {
if (cancelled) return;
setRemoteSessions(remoteChatSessionSchema.array().parse(result));
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
historySessionId,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
transport: selectedTransport,
};
setCapabilities(null);
2026-07-21 15:25:11 +08:00
if (!snapshot.profileId || snapshot.transport !== "astr-bot-open-api")
return;
let cancelled = false;
void invoke<unknown>("connection_slot_capabilities", {
request: { slot: selectedSlot },
})
.then((result) => {
if (cancelled) return;
const next = astrbotCapabilitySnapshotSchema.parse(result);
setCapabilities(next);
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
historySessionId,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: historySessionId,
transport: selectedTransport,
};
if (
!snapshot.profileId ||
!snapshot.serverInstanceId ||
!snapshot.activeSessionId
)
return;
void invoke("mark_chat_session_read", {
request: {
profileId: snapshot.profileId,
slot: selectedSlot,
serverInstanceId: snapshot.serverInstanceId,
sessionId: snapshot.activeSessionId,
},
}).catch(() => undefined);
setUnreadCounts((current) => ({ ...current, [selectedSlot]: 0 }));
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
historySessionId,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: historySessionId,
transport: selectedTransport,
};
if (
!snapshot.profileId ||
!snapshot.serverInstanceId ||
!snapshot.activeSessionId
)
return;
let cancelled = false;
void invoke<unknown>("load_chat_messages", {
request: {
profileId: snapshot.profileId,
slot: selectedSlot,
serverInstanceId: snapshot.serverInstanceId,
sessionId: snapshot.activeSessionId,
limit: 100,
},
})
.then((result) => {
if (cancelled) return;
const records = storedChatMessageSchema.array().parse(result);
setMessages((current) =>
mergeLoadedChatMessages(
current,
records,
selectedSlot,
snapshot.activeSessionId,
),
);
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
historySessionId,
selectedTransport,
]);
useEffect(() => {
let timer: number | undefined;
void refresh().then((available) => {
if (!available) return;
timer = window.setInterval(() => {
void refresh();
}, 500);
});
return () => {
if (timer !== undefined) window.clearInterval(timer);
};
}, [refresh]);
const uploadFiles = async (files: FileList | null) => {
if (!files?.length) return;
setUploading(true);
setError(null);
try {
const uploaded: AstrBotAttachment[] = [];
for (const file of Array.from(files)) {
if (file.size > 16 * 1024 * 1024)
throw new Error(`${file.name} 超过 16 MiB 限制`);
const bytes = Array.from(new Uint8Array(await file.arrayBuffer()));
const result = await invoke<unknown>("upload_connection_slot_file", {
request: {
slot: selectedSlot,
fileName: file.name,
mimeType: file.type || "application/octet-stream",
bytes,
},
});
uploaded.push(astrbotAttachmentSchema.parse(result));
}
setPendingAttachments((current) => current.concat(uploaded));
} catch (reason) {
setError(errorMessage(reason));
} finally {
setUploading(false);
}
};
2026-07-21 15:25:11 +08:00
const send = async (messageOverride?: string) => {
const message =
2026-07-21 15:25:11 +08:00
messageOverride?.trim() ||
draft.trim() ||
2026-07-21 15:25:11 +08:00
(pendingAttachments.length > 0 ? "Please check the attachment." : "");
if (!message || uploading || sending[selectedSlot]) return;
const id = `local-${Date.now()}`;
2026-07-21 15:25:11 +08:00
const attachments = messageOverride ? [] : pendingAttachments;
setDraft("");
2026-07-21 15:25:11 +08:00
if (!messageOverride) setPendingAttachments([]);
setSending((current) => ({ ...current, [selectedSlot]: true }));
setMessages((current) =>
current.concat({
id,
sessionId: status[selectedSlot].activeSessionId,
slot: selectedSlot,
role: "user",
content: message,
}),
);
try {
const result = slotRuntimeSnapshotSchema.parse(
await invoke<unknown>("send_connection_slot_message", {
request: {
slot: selectedSlot,
message,
attachments,
},
}),
);
setStatus((current) => ({ ...current, [selectedSlot]: result }));
setMessages((current) =>
current.map((item) =>
item.id === id
? { ...item, sessionId: result.activeSessionId }
: item,
),
);
setError(null);
} catch (reason) {
setError(errorMessage(reason));
setMessages((current) =>
current.map((item) =>
item.id === id ? { ...item, error: true } : item,
),
);
2026-07-21 15:25:11 +08:00
} finally {
setSending((current) => ({ ...current, [selectedSlot]: false }));
}
};
const stopGeneration = async () => {
try {
await invoke("cancel_connection_slot_message", {
request: { slot: selectedSlot },
});
setSending((current) => ({ ...current, [selectedSlot]: false }));
setMessages((current) =>
current.map((item) =>
item.slot === selectedSlot && item.streaming
? {
...item,
streaming: false,
content: item.content || "Generation stopped.",
error: true,
}
: item,
),
);
setError(null);
} catch (reason) {
setError(errorMessage(reason));
2026-07-21 15:25:11 +08:00
}
};
const copyMessage = async (content: string) => {
try {
await navigator.clipboard.writeText(content);
setError(null);
} catch {
setError("复制失败,请检查剪贴板权限。");
2026-07-21 15:25:11 +08:00
}
};
const retryMessage = (messageId: string) => {
const index = messages.findIndex((item) => item.id === messageId);
const previousUser = [...messages]
.slice(0, index)
.reverse()
.find((item) => item.role === "user" && item.slot === selectedSlot);
if (previousUser) void send(previousUser.content);
};
const startNewSession = async () => {
if (
!status[selectedSlot].state ||
status[selectedSlot].state === "disconnected"
) {
setError("Connect the selected slot first.");
return;
}
try {
const sessionId = crypto.randomUUID();
const result = slotRuntimeSnapshotSchema.parse(
await invoke<unknown>("switch_connection_slot_session", {
request: { slot: selectedSlot, sessionId },
}),
);
setMessages((current) =>
current.filter(
(item) =>
item.slot !== selectedSlot ||
item.sessionId !== status[selectedSlot].activeSessionId,
),
);
setStatus((current) => ({ ...current, [selectedSlot]: result }));
setError(null);
} catch (reason) {
setError(errorMessage(reason));
2026-07-21 15:25:11 +08:00
}
};
const refreshConnection = async () => {
await refresh();
};
const reconnectConnection = async () => {
const profileId = status[selectedSlot].profileId;
if (!profileId) {
setError("No Profile is assigned to the selected slot.");
return;
}
try {
const result = slotRuntimeSnapshotSchema.parse(
await invoke<unknown>("probe_connection_slot", {
request: { slot: selectedSlot, profileId },
}),
);
setStatus((current) => ({ ...current, [selectedSlot]: result }));
setError(null);
} catch (reason) {
setError(errorMessage(reason));
2026-07-21 15:25:11 +08:00
}
};
const disconnectConnection = async () => {
try {
await invoke("disconnect_connection_slot", {
request: { slot: selectedSlot },
});
await refresh();
} catch (reason) {
setError(errorMessage(reason));
}
};
const toggleVoiceInput = () => {
if (voiceListening) {
speechRecognition.current?.stop();
setVoiceListening(false);
return;
}
const browserWindow = window as unknown as {
SpeechRecognition?: new () => SpeechRecognitionLike;
webkitSpeechRecognition?: new () => SpeechRecognitionLike;
};
const Recognition =
browserWindow.SpeechRecognition ?? browserWindow.webkitSpeechRecognition;
if (!Recognition) {
setError("当前 WebView 不支持语音输入。");
return;
}
const recognition = new Recognition();
recognition.lang = "zh-CN";
recognition.interimResults = true;
recognition.onresult = (event) => {
const result = event as {
results?: ArrayLike<ArrayLike<{ transcript?: string }>>;
};
setDraft(
Array.from(result.results ?? [])
.map((item) => item[0]?.transcript ?? "")
.join(""),
);
};
recognition.onerror = () => {
setError("语音输入失败,请检查麦克风权限。");
setVoiceListening(false);
};
recognition.onend = () => setVoiceListening(false);
speechRecognition.current = recognition;
recognition.start();
setVoiceListening(true);
};
const speakMessage = (content: string) => {
if (!window.speechSynthesis) return;
window.speechSynthesis.cancel();
const utterance = new SpeechSynthesisUtterance(content);
utterance.lang = "zh-CN";
window.speechSynthesis.speak(utterance);
};
return (
<section className="chat-panel" aria-label="聊天面板">
<div className="chat-heading">
<div>
<p className="eyebrow">共享聊天运行时</p>
<h2>统一聊天运行时</h2>
<p className="chat-note">
主界面、快速聊天和气泡共享同一套消息状态。
</p>
</div>
<div className="chat-slot-tabs" role="tablist" aria-label="聊天槽位">
{(["companion", "operations"] as const).map((slot) => (
<button
className={activeSlot === slot ? "chat-slot active" : "chat-slot"}
key={slot}
disabled={Boolean(fixedSlot)}
onClick={() => setActiveSlot(slot)}
role="tab"
aria-selected={activeSlot === slot}
aria-controls={`chat-panel-${slot}`}
tabIndex={fixedSlot || activeSlot === slot ? 0 : -1}
onKeyDown={(event) => {
if (event.key !== "ArrowRight" && event.key !== "ArrowLeft")
return;
event.preventDefault();
setActiveSlot(
slot === "companion" ? "operations" : "companion",
);
}}
type="button"
>
{slot === "companion" ? "陪伴" : "运维"}
{unreadCounts[slot] > 0 ? (
<strong>{unreadCounts[slot]}</strong>
) : null}
<span>{connectionStateLabel(status[slot].state)}</span>
</button>
))}
</div>
</div>
<div className="chat-runtime-strip">
2026-07-21 15:25:11 +08:00
<div>
<span>配置</span>
<strong>{status[selectedSlot].profileId ?? "未连接"}</strong>
2026-07-21 15:25:11 +08:00
</div>
<div>
<span>会话</span>
<strong>{status[selectedSlot].activeSessionId ?? "新会话"}</strong>
2026-07-21 15:25:11 +08:00
</div>
<div>
<span>状态</span>
2026-07-21 15:25:11 +08:00
<strong>{connectionStateLabel(status[selectedSlot].state)}</strong>
</div>
<div className="chat-runtime-actions">
<button type="button" onClick={() => void refreshConnection()}>
刷新
2026-07-21 15:25:11 +08:00
</button>
<button type="button" onClick={() => void reconnectConnection()}>
重连
2026-07-21 15:25:11 +08:00
</button>
<button
type="button"
onClick={() => void disconnectConnection()}
disabled={status[selectedSlot].state === "disconnected"}
>
断开
2026-07-21 15:25:11 +08:00
</button>
<button type="button" onClick={() => void startNewSession()}>
新对话
2026-07-21 15:25:11 +08:00
</button>
</div>
</div>
2026-07-21 15:25:11 +08:00
{status[selectedSlot].lastError ? (
<p className="chat-runtime-error" role="status">
{status[selectedSlot].lastError}
</p>
) : null}
{status[selectedSlot].state === "authExpired" ? (
<div className="warning-banner" role="alert">
<strong>认证已过期</strong>
<span>
请到“连接”设置重新登录 AstrBot,当前槽位不会继续发送消息。
</span>
<button type="button" onClick={() => void invoke("open_main_window")}>
打开连接设置
</button>
</div>
) : null}
{displaySessions.length > 0 ? (
<div className="chat-session-list" aria-label="Chat sessions">
{displaySessions.map((session, index) => (
<button
className={
session.sessionId === status[selectedSlot].activeSessionId
? "chat-session active"
: "chat-session"
}
key={session.sessionId}
title={`会话标识:${session.sessionId}`}
type="button"
onClick={() => {
void invoke("switch_connection_slot_session", {
request: { slot: selectedSlot, sessionId: session.sessionId },
})
.then(() => void refresh())
.catch((reason) =>
setError(
errorMessage(reason),
),
);
}}
>
<strong>{session.displayName || `会话 ${index + 1}`}</strong>
<small>{formatSessionTime(session.updatedAt)}</small>
</button>
))}
</div>
) : null}
<div
id={`chat-panel-${selectedSlot}`}
className="chat-message-list"
role="tabpanel"
aria-label={`${selectedSlot} messages`}
aria-busy={sending[selectedSlot]}
aria-live="polite"
>
{visibleMessages.length === 0 ? (
<p className="chat-empty">
当前槽位还没有消息。连接 Profile 后即可开始聊天。
</p>
) : (
2026-07-21 15:25:11 +08:00
visibleMessages.map((message) => {
return (
<article
className={`chat-message-row ${message.role}${message.error ? " failed" : ""}`}
key={message.id}
>
<div className="chat-avatar" aria-hidden="true">
{message.role === "user"
? "You"
: message.role === "assistant"
? "A"
: "!"}
</div>
<div className="chat-message-content">
<div className="chat-bubble">
<div className="chat-bubble-header">
<span>
{message.role === "user"
? "你"
: message.role === "assistant"
? "AstrBot"
: "系统"}
</span>
{message.streaming ? <small>生成中</small> : null}
</div>
{message.content ? (
<MessageContent content={message.content} slot={selectedSlot} />
) : (
<p className="message-placeholder">正在生成…</p>
)}
2026-07-21 15:25:11 +08:00
</div>
{message.role === "assistant" &&
message.content &&
!message.streaming ? (
<div className="chat-message-actions" aria-label="消息操作">
2026-07-21 15:25:11 +08:00
<button
type="button"
aria-label="复制消息"
title="复制消息"
2026-07-21 15:25:11 +08:00
onClick={() => void copyMessage(message.content)}
>
<span
className="message-action-icon icon-copy"
aria-hidden="true"
/>
<span>复制</span>
2026-07-21 15:25:11 +08:00
</button>
<button
type="button"
aria-label="重试消息"
title="重试消息"
2026-07-21 15:25:11 +08:00
onClick={() => retryMessage(message.id)}
>
<span
className="message-action-icon icon-retry"
aria-hidden="true"
/>
<span>重试</span>
2026-07-21 15:25:11 +08:00
</button>
<button
type="button"
aria-label="朗读消息"
title="朗读消息"
2026-07-21 15:25:11 +08:00
onClick={() => speakMessage(message.content)}
>
<span
className="message-action-icon icon-read"
aria-hidden="true"
/>
<span>朗读</span>
2026-07-21 15:25:11 +08:00
</button>
</div>
) : null}
{message.streaming && sending[selectedSlot] ? (
<button
className="chat-stop-button"
type="button"
onClick={() => void stopGeneration()}
>
停止生成
2026-07-21 15:25:11 +08:00
</button>
) : null}
</div>
</article>
);
})
)}
</div>
{error ? (
<p className="chat-error" role="alert">
{error}
</p>
) : null}
<div className="chat-composer-toolbar">
<label className="file-picker">
<span>添加图片/文件</span>
<input
className="file-picker-input"
type="file"
multiple
onChange={(event) => {
void uploadFiles(event.target.files);
event.target.value = "";
}}
disabled={uploading || !capabilities?.fileUpload}
/>
</label>
{uploading ? <span className="toolbar-note">上传中…</span> : null}
<button
type="button"
onClick={toggleVoiceInput}
className={voiceListening ? "voice-button active" : "voice-button"}
aria-pressed={voiceListening}
>
{voiceListening ? "停止录音" : "语音输入"}
</button>
</div>
{pendingAttachments.length > 0 ? (
<div className="attachment-list">
{pendingAttachments.map((attachment) => (
<span key={attachment.attachmentId}>
{attachment.fileName}
<button
type="button"
aria-label={`移除 ${attachment.fileName}`}
onClick={() =>
setPendingAttachments((current) =>
current.filter(
(item) => item.attachmentId !== attachment.attachmentId,
),
)
}
>
×
</button>
</span>
))}
</div>
) : null}
<form
className="chat-composer"
onSubmit={(event) => {
event.preventDefault();
void send();
}}
>
<textarea
aria-label="聊天消息"
onChange={(event) => setDraft(event.target.value)}
placeholder={
selectedSlot === "companion"
? "和陪伴实例说点什么…(Enter 发送,Shift+Enter 换行)"
: "向运维实例描述问题…(Enter 发送,Shift+Enter 换行)"
}
value={draft}
rows={3}
onKeyDown={(event) => {
if (
event.key !== "Enter" ||
event.shiftKey ||
event.nativeEvent.isComposing
)
return;
event.preventDefault();
void send();
}}
/>
<button
className="chat-send-button"
disabled={
(!draft.trim() && pendingAttachments.length === 0) || uploading
}
type="submit"
>
<span className="send-button-icon" aria-hidden="true">
↑
</span>
<span>发送</span>
</button>
</form>
</section>
);
}
function applyRuntimeEvents(
current: ChatMessage[],
events: BoundRuntimeEvent[],
): ChatMessage[] {
const next = current.map((item) => ({ ...item }));
for (const event of events) {
if (event.eventType === "message.delta") {
const id =
event.messageId || payloadString(event, "messageId") || event.eventId;
const delta =
payloadString(event, "delta") || payloadString(event, "content") || "";
const existing = next.find(
(item) =>
item.id === id &&
item.slot === event.slot &&
item.sessionId === event.sessionId,
);
if (existing) {
existing.content += delta;
existing.streaming = true;
} else
next.push({
id,
sessionId: event.sessionId,
slot: event.slot,
role: "assistant",
content: delta,
streaming: true,
});
} else if (event.eventType === "message.completed") {
const id =
event.messageId || payloadString(event, "messageId") || event.eventId;
const existing = next.find(
(item) =>
item.id === id &&
item.slot === event.slot &&
item.sessionId === event.sessionId,
);
const completedContent = payloadString(event, "content")?.trim() ?? "";
if (existing) {
if (completedContent) {
existing.content = completedContent;
} else if (!existing.content.trim()) {
existing.content = "未收到有效回复";
existing.error = true;
}
existing.streaming = false;
} else
next.push({
id,
sessionId: event.sessionId,
slot: event.slot,
role: "assistant",
content: completedContent || "未收到有效回复",
error: !completedContent,
});
} else if (event.eventType === "error") {
next.push({
id: event.eventId,
sessionId: event.sessionId,
slot: event.slot,
role: "system",
content: payloadString(event, "message") || "连接错误",
error: true,
});
} else if (event.eventType === "message.proactive") {
next.push({
id: event.eventId,
sessionId: event.sessionId,
slot: event.slot,
role: "assistant",
content: payloadString(event, "content") || "",
});
}
}
return next;
}
function formatSessionTime(value?: string): string {
if (!value) return "本地历史";
const date = new Date(value);
if (Number.isNaN(date.getTime())) return "本地历史";
return new Intl.DateTimeFormat("zh-CN", {
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
}).format(date);
}
function connectionStateLabel(
state: ConnectionRuntimeStatus["companion"]["state"],
): string {
const labels: Record<typeof state, string> = {
disconnected: "未连接",
connecting: "连接中",
authenticating: "认证中",
syncing: "同步中",
connected: "已连接",
reconnecting: "重连中",
authExpired: "认证已过期",
incompatible: "协议不兼容",
serverUnavailable: "服务不可用",
offline: "离线",
certificateChanged: "证书已变更",
fatalError: "连接错误",
};
return labels[state];
}