AstrBot-Desktop/src/features/chat/ChatPanel.tsx
YokiiroBW ceb7512bf2
一些检测仍在等待运行
ci / Portable quality checks (push) Waiting to run
ci / Windows Tauri build (push) Waiting to run
feat(desktop): complete Q9 chat and stability increment
2026-07-21 14:43:14 +08:00

739 行
23 KiB
TypeScript

此文件含有模棱两可的 Unicode 字符

此文件含有可能会与其他字符混淆的 Unicode 字符。 如果您是想特意这样的,可以安全地忽略该警告。 使用 Escape 按钮显示他们。

import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import {
astrbotAttachmentSchema,
astrbotCapabilitySnapshotSchema,
boundRuntimeEventSchema,
chatSessionSchema,
connectionRuntimeStatusSchema,
type AstrBotAttachment,
type AstrBotCapabilitySnapshot,
type BoundRuntimeEvent,
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 [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 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);
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(
(message) => message.content.trim().length > 0 || message.streaming || message.error,
),
[activeMessages],
);
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);
setUnreadCounts((current) => ({
...current,
[selectedSlot]: sessions.reduce(
(total, session) => total + session.unreadCount,
0,
),
}));
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
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,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
transport: selectedTransport,
};
setCapabilities(null);
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,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
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,
selectedTransport,
]);
useEffect(() => {
const snapshot = {
profileId: selectedProfileId,
serverInstanceId: selectedServerInstanceId,
activeSessionId: selectedSessionId,
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) => {
const localUserMessages = current.filter(
(item) =>
(item.id.startsWith("local-") || item.streaming) &&
item.slot === selectedSlot &&
item.sessionId === snapshot.activeSessionId,
);
return current
.filter(
(item) =>
item.slot !== selectedSlot ||
item.sessionId !== snapshot.activeSessionId,
)
.concat(localUserMessages)
.concat(
records.map((record) => ({
id: record.messageId,
sessionId: record.sessionId,
slot: record.slot,
role: record.role,
content: record.content,
streaming: record.streaming,
error: record.error,
})),
);
});
})
.catch(() => undefined);
return () => {
cancelled = true;
};
}, [
selectedSlot,
selectedProfileId,
selectedServerInstanceId,
selectedSessionId,
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(reason instanceof Error ? reason.message : String(reason));
} finally {
setUploading(false);
}
};
const send = async () => {
const message =
draft.trim() ||
(pendingAttachments.length > 0 ? "请查看我发送的附件。" : "");
if (!message || uploading) return;
const id = `local-${Date.now()}`;
const attachments = pendingAttachments;
setDraft("");
setPendingAttachments([]);
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(reason instanceof Error ? reason.message : String(reason));
setMessages((current) =>
current.map((item) =>
item.id === id ? { ...item, error: true } : item,
),
);
}
};
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">Shared chat runtime</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}
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">
<span>Profile:{status[selectedSlot].profileId ?? "未连接"}</span>
<span>Session:{status[selectedSlot].activeSessionId ?? "未建立"}</span>
<span>状态:{connectionStateLabel(status[selectedSlot].state)}</span>
</div>
{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}
{remoteSessions.length > 0 ? (
<div className="chat-session-list" aria-label="Chat sessions">
{remoteSessions.map((session) => (
<button
className={
session.sessionId === status[selectedSlot].activeSessionId
? "chat-session active"
: "chat-session"
}
key={session.sessionId}
type="button"
onClick={() => {
void invoke("switch_connection_slot_session", {
request: { slot: selectedSlot, sessionId: session.sessionId },
})
.then(() => void refresh())
.catch((reason) =>
setError(
reason instanceof Error ? reason.message : String(reason),
),
);
}}
>
<strong>{session.displayName || session.sessionId}</strong>
<small>{session.updatedAt || "Remote session"}</small>
</button>
))}
</div>
) : null}
<div className="chat-message-list" aria-live="polite">
{visibleMessages.length === 0 ? (
<p className="chat-empty">
当前槽位还没有消息。连接 Profile 后即可开始聊天。
</p>
) : (
visibleMessages.map((message) => (
<article
className={`chat-message-row ${message.role}${message.error ? " failed" : ""}`}
key={message.id}
>
<div className="chat-avatar" aria-hidden="true">
{message.role === "user" ? "我" : message.role === "assistant" ? "A" : "!"}
</div>
<div className="chat-bubble">
<div className="chat-bubble-header">
<span>{message.role === "user" ? "我" : message.role === "assistant" ? "AstrBot" : "系统"}</span>
{message.streaming ? <small>生成中…</small> : null}
</div>
<p>{message.content || "生成中…"}</p>
{message.role === "assistant" && message.content ? (
<button
className="chat-message-read"
type="button"
onClick={() => speakMessage(message.content)}
>
朗读
</button>
) : null}
</div>
</article>
))
)}
</div>
{error ? <p className="chat-error">{error}</p> : null}
<div className="chat-composer-toolbar">
<label className="file-picker">
<span>添加图片/文件</span>
<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"}
>
{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"
? "和陪伴实例说点什么…"
: "向运维实例描述问题…"
}
value={draft}
rows={3}
/>
<button
disabled={
(!draft.trim() && pendingAttachments.length === 0) || uploading
}
type="submit"
>
发送
</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 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];
}