import { API_V1, CREDENTIALS, checkTenant, signal, UNAUTHORIZED_EVENT } from "../apiContract"; import { refusalPair, refusalSentence, type ChatResult } from "../query/queryApi"; type StreamLine = { message?: string; label?: string; name?: string; [key: string]: unknown }; type StreamError = StreamLine & { status?: number; code?: string; retry?: boolean; result?: unknown; error?: { message?: string; code?: string } }; export type ChatStreamEvent = | { type: "thinking"; data: StreamLine } | { type: "tool_step"; data: StreamLine } | { type: "text_delta"; data: string | { delta?: string; text?: string; content?: string } } | { type: "joined"; data: Record } | { type: "paused"; data: Record } | { type: "done"; data: ChatResult } | { type: "error"; data: StreamError }; export type ChatStreamResult = Extract; export type ChatStreamRequest = { question: string; database: string; sources: string[]; model: string }; export class ChatStreamFailure extends Error { readonly fallbackEligible: boolean; readonly admitted: boolean; /** C2: the server's refusal code, when the response or error event carried one. */ readonly code?: string; constructor(message: string, fallbackEligible: boolean, admitted = false, code?: string) { super(message); this.fallbackEligible = fallbackEligible; this.admitted = admitted; if (code) this.code = code; } } export function streamDelta(data: Extract["data"]): string { return typeof data === "string" ? data : data.delta ?? data.text ?? data.content ?? ""; } function boundaryFailure(status: number, code = ""): boolean { return [401, 403, 409].includes(status) || /unauthorized|forbidden|refused|tenant|permission/i.test(code); } function completedResult(value: unknown): value is ChatResult { if (!value || typeof value !== "object") return false; const result = value as Partial; return typeof result.userMessage?.id === "string" && result.userMessage.id.trim().length > 0 && typeof result.message?.id === "string" && result.message.id.trim().length > 0 && result.userMessage.id !== result.message.id && result.userMessage.role === "user" && result.message.role === "assistant" && typeof result.message.threadId === "string" && result.message.threadId.length > 0 && result.userMessage.threadId === result.message.threadId && typeof result.message.content === "string" && Array.isArray(result.citations); } /** Read C3 records across arbitrary UTF-8 and SSE chunk boundaries. */ export async function streamChat(body: ChatStreamRequest, onEvent: (event: ChatStreamEvent) => void, abortSignal?: AbortSignal): Promise { abortSignal?.throwIfAborted(); let response: Response; try { response = await fetch(`${API_V1}/query/chat/stream`, { method: "POST", credentials: CREDENTIALS, signal: abortSignal, headers: { "Content-Type": "application/json", Accept: "text/event-stream" }, body: JSON.stringify(body), }); } catch { abortSignal?.throwIfAborted(); // Losing the response cannot establish that the server refused admission. Read its log. throw new ChatStreamFailure(refusalSentence(), false, true); } abortSignal?.throwIfAborted(); if (checkTenant(response)) throw new ChatStreamFailure("The workspace changed. Open this chat again.", false); if (response.status === 401) signal(UNAUTHORIZED_EVENT); if (!response.ok) { const detail = await response.json().catch(() => null) as StreamError | null; const { code } = refusalPair(detail); throw new ChatStreamFailure(refusalSentence(code), !boundaryFailure(response.status, code), false, code); } if (response.headers.get("Content-Type")?.split(";")[0].trim().toLowerCase() !== "text/event-stream" || !response.body) throw new ChatStreamFailure("The answer stream is unavailable.", true); const reader = response.body.getReader(); const decoder = new TextDecoder(); // An accepted SSE response belongs to an admitted turn, even before its first frame. let buffer = "", content = "", admitted = true; let rejectAbort: (reason: unknown) => void = () => {}; const aborted = new Promise((_, reject) => { rejectAbort = reject; }); const cancel = () => { rejectAbort(abortSignal?.reason || new DOMException("Aborted", "AbortError")); void reader.cancel().catch(() => {}); }; abortSignal?.addEventListener("abort", cancel, { once: true }); try { abortSignal?.throwIfAborted(); for (;;) { const chunk = await Promise.race([reader.read(), aborted]); abortSignal?.throwIfAborted(); buffer += decoder.decode(chunk.value, { stream: !chunk.done }); let record: RegExpExecArray | null; while ((record = /\r?\n\r?\n/.exec(buffer))) { const lines = buffer.slice(0, record.index).split(/\r?\n/); buffer = buffer.slice(record.index + record[0].length); const type = lines.find((line) => line.startsWith("event:"))?.slice(6).trim(); const data = lines.filter((line) => line.startsWith("data:")) .map((line) => line.slice(5).replace(/^ /, "")).join("\n"); if (!data || !type) continue; if (!["thinking", "tool_step", "text_delta", "joined", "paused", "done", "error"].includes(type)) continue; const event = { type, data: JSON.parse(data) } as ChatStreamEvent; admitted = true; if (event.type === "text_delta") content += streamDelta(event.data); if (event.type === "done" && (!completedResult(event.data) || event.data.message.content !== content)) throw new ChatStreamFailure("The answer stream was incomplete.", false, admitted); if (event.type === "error" && event.data.result) { if (completedResult(event.data.result)) { const recovered: ChatStreamResult = { type: "done", data: event.data.result }; onEvent(recovered); return recovered; } const controlled = event.data.result as { status?: unknown }; if (controlled.status === "joined" || controlled.status === "stopped") { const joined: ChatStreamResult = { type: "joined", data: { status: controlled.status } }; onEvent(joined); return joined; } } onEvent(event); if (event.type === "error") { const { code } = refusalPair(event.data); throw new ChatStreamFailure(refusalSentence(code), !admitted && event.data.retry !== false && !boundaryFailure(event.data.status || 0, code), admitted, code); } if (event.type === "done" || event.type === "joined") return event; } if (chunk.done) throw new ChatStreamFailure("The answer stream ended before the answer was saved.", false, true); } } catch (error) { abortSignal?.throwIfAborted(); if (error instanceof ChatStreamFailure) throw error; throw new ChatStreamFailure(refusalSentence(), !admitted, admitted); } finally { abortSignal?.removeEventListener("abort", cancel); void reader.cancel().catch(() => {}); reader.releaseLock(); } } export function canFallback(error: unknown, abortSignal?: AbortSignal): boolean { if (abortSignal?.aborted || (error instanceof Error && error.name === "AbortError")) return false; return error instanceof ChatStreamFailure ? error.fallbackEligible : error instanceof TypeError || error instanceof SyntaxError; }