多智能问答

This commit is contained in:
董宏凯 committed 2026-05-24 21:13:19 +08:00
1 parent 77db1a6297
commit 05815d9475
11 files changed
+2045 -727

No files matched your search

@@ -41,6 +41,24 @@ export interface InitMultiAgentResponse {
export async function initMultiAgent(
payload: InitMultiAgentRequest,
): Promise<InitMultiAgentResponse> {
// Timing telemetry for /api/multi-agent/init — enabled by default so we can
// see where time goes when users report "Step 2 init feels slow". Disable
// with `window.__MULTI_AGENT_INIT_TIMING__ = false` in devtools.
const timingEnabled =
typeof window === "undefined"
? false
: (window as unknown as { __MULTI_AGENT_INIT_TIMING__?: boolean }).__MULTI_AGENT_INIT_TIMING__ !== false;
const t0 = performance.now();
let tFirstByte = 0;
let tCoord = 0;
let seatCount = 0;
const tlog = (label: string) => {
if (!timingEnabled) return;
const elapsed = (performance.now() - t0).toFixed(0);
console.debug(`[init-timing] +${elapsed}ms ${label}`);
};
tlog("fetch.start");
const res = await apiFetch(`${getBackendBaseURL()}/api/multi-agent/init`, {
method: "POST",
headers: { "Content-Type": "application/json" },
@@ -51,6 +69,7 @@ export async function initMultiAgent(
}),
signal: payload.signal,
});
tlog(`fetch.headers status=${res.status}`);
if (!res.ok || !res.body) {
const text = await res.text().catch(() => "");
throw new Error(`init multi-agent failed (${res.status}): ${text}`);
@@ -68,6 +87,10 @@ export async function initMultiAgent(
while (true) {
const { done, value } = await reader.read();
if (done) break;
if (tFirstByte === 0) {
tFirstByte = performance.now();
tlog(`first-byte (TTFB-after-headers=${(tFirstByte - t0).toFixed(0)}ms)`);
}
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split("\n");
buffer = lines.pop() ?? "";
@@ -88,6 +111,8 @@ export async function initMultiAgent(
const event = typeof obj.event === "string" ? obj.event : "";
switch (event) {
case "seat_ready": {
seatCount += 1;
tlog(`seat_ready #${seatCount} ${String(obj.agent_name ?? "?")}`);
payload.onSeatReady?.({
agentName: String(obj.agent_name ?? ""),
threadId: String(obj.thread_id ?? ""),
@@ -97,6 +122,8 @@ export async function initMultiAgent(
break;
}
case "coordinator_ready": {
tCoord = performance.now();
tlog(`coordinator_ready (since-first-seat=${(tCoord - tFirstByte).toFixed(0)}ms)`);
payload.onCoordinatorReady?.({
mainAgentName: String(obj.main_agent_name ?? ""),
threadId: String(obj.thread_id ?? ""),
@@ -104,6 +131,7 @@ export async function initMultiAgent(
break;
}
case "init_done": {
tlog(`init_done seats=${seatCount}`);
mainAgentName = String(obj.main_agent_name ?? "");
threadIds = (obj.thread_ids ?? {}) as ThreadIdMap;
break;
@@ -123,6 +151,8 @@ export async function initMultiAgent(
if (!aborted) throw err;
}
tlog(`total ${(performance.now() - t0).toFixed(0)}ms (seats=${seatCount})`);
if (errorDetail) {
throw new Error(`init multi-agent failed: ${errorDetail}`);
}
@@ -276,44 +306,6 @@ function extractAiTextDelta(parsed: unknown): { text: string; id: string } | nul
return { text, id };
}
/**
* Trigger a browser download for a text blob. No-op outside the browser.
* Used by streamMultiAgent's dump-to-file debug mode.
*/
function downloadTextBlob(filename: string, text: string): void {
if (typeof window === "undefined" || typeof document === "undefined") return;
try {
const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url;
a.download = filename;
a.style.display = "none";
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
// Defer revoke so the browser has a chance to start the download.
setTimeout(() => URL.revokeObjectURL(url), 60_000);
} catch (err) {
// Downloads must never break the actual stream — just log and continue.
console.warn("[stream] downloadTextBlob failed:", err);
}
}
/**
* Whether streamMultiAgent should auto-download the raw SSE transcript to a
* .txt when each call ends. Default ON for now because we're debugging the
* "sub-agent stream looks empty" issue and the browser console truncates
* large message logs. Toggle from devtools:
* window.__MULTI_AGENT_DUMP__ = false
*/
function isDumpEnabled(): boolean {
if (typeof window === "undefined") return false;
const flag = (window as unknown as { __MULTI_AGENT_DUMP__?: boolean }).__MULTI_AGENT_DUMP__;
// Default: enabled. Only disabled if explicitly set to false.
return flag !== false;
}
/**
* Open an SSE connection to /api/multi-agent/run/stream and resolve once the
* stream completes. The final frame (`{status: ...}`) is interpreted; every
@@ -357,24 +349,6 @@ export async function streamMultiAgent(
typeof window !== "undefined" &&
(window as unknown as { __MULTI_AGENT_DEBUG__?: boolean }).__MULTI_AGENT_DEBUG__ !== false;
// Raw SSE transcript buffer. Every raw line read from the stream (event:,
// data:, blank framing lines, anything) is appended verbatim so the dumped
// .txt is byte-for-byte what the frontend received off the socket. This is
// independent of parsing: even malformed/non-JSON frames end up in the file.
const dumpEnabled = isDumpEnabled();
const transcript: string[] = dumpEnabled
? [
`# multi-agent stream transcript`,
`# agent_type: ${req.agentType}`,
`# agent_name: ${req.agentName}`,
`# started_at: ${new Date().toISOString()}`,
`# new_message: ${req.newMessage.replace(/\n/g, " ⏎ ")}`,
`# model: ${req.model ?? "(default)"}`,
`# ---- raw SSE follows ----`,
"",
]
: [];
const result: StreamMultiAgentResult = {
dispatched: [],
message: null,
@@ -393,38 +367,16 @@ export async function streamMultiAgent(
req.onPhaseChange?.(next, name);
};
// Wrap the read loop so we always flush the transcript to disk, even on
// abort / network failure. Otherwise an interrupted run would lose the very
// evidence we want to inspect.
const finishDump = (reason: string) => {
if (!dumpEnabled) return;
transcript.push("");
transcript.push(`# ---- stream ended (${reason}) ----`);
transcript.push(`# ended_at: ${new Date().toISOString()}`);
transcript.push(`# frames_parsed: ${frameSeq}`);
transcript.push(`# final_content_length: ${result.content.length}`);
transcript.push(`# dispatched_count: ${result.dispatched.length}`);
const tsSafe = new Date().toISOString().replace(/[:.]/g, "-");
const nameSafe = req.agentName.replace(/[^a-zA-Z0-9_-]/g, "_");
const filename = `multi-agent_${req.agentType}_${nameSafe}_${tsSafe}.txt`;
downloadTextBlob(filename, transcript.join("\n"));
};
while (true) {
const { done, value } = await reader.read();
if (done) break;
const chunk = decoder.decode(value, { stream: true });
buffer += chunk;
try {
while (true) {
const { done, value } = await reader.read();
if (done) break;
const chunk = decoder.decode(value, { stream: true });
buffer += chunk;
const lines = buffer.split("\n");
buffer = lines.pop() ?? "";
for (const rawLine of lines) {
// Record EVERY raw line — including blank framing lines and event:
// headers — so the dumped transcript matches what the socket sent.
if (dumpEnabled) transcript.push(rawLine);
const lines = buffer.split("\n");
buffer = lines.pop() ?? "";
for (const rawLine of lines) {
const line = rawLine.trimEnd();
if (!line) continue;
if (line.startsWith("event:")) {
@@ -525,16 +477,82 @@ export async function streamMultiAgent(
}
}
if (debugEnabled) {
console.debug(debugLabel, `stream ended after ${frameSeq} frames; final content length=${result.content.length}`);
}
finishDump("normal");
return result;
} catch (err) {
// Flush whatever we got so the user can still inspect the transcript on
// abort / network drop. Then rethrow so callers' own handling runs.
const aborted = (err as Error)?.name === "AbortError" || req.signal?.aborted === true;
finishDump(aborted ? "aborted" : `error: ${(err as Error)?.message ?? String(err)}`);
throw err;
if (debugEnabled) {
console.debug(debugLabel, `stream ended after ${frameSeq} frames; final content length=${result.content.length}`);
}
return result;
}
export interface SessionArtifactFile {
/** Virtual path under the sandbox, e.g. `mnt/user-data/outputs/foo.md`. */
path: string;
/** Bare filename (basename of `path`). */
name: string;
sizeBytes: number;
/** MIME type guessed from the extension, or null when unknown. */
mimeType: string | null;
/** ISO 8601 UTC timestamp of last modification. */
modifiedAt: string;
}
export interface SessionArtifactsResponse {
threadId: string;
files: SessionArtifactFile[];
}
/**
* List every file written to `/mnt/user-data/outputs/` for a thread. Used by
* the Step 3 final-report view to surface a thread's produced artifacts so the
* user can preview/download them via {@link buildArtifactDownloadUrl}.
*
* Returns an empty `files` array when the thread produced no artifacts (the
* backend treats a missing outputs directory as empty, not 404).
*/
export async function listSessionArtifacts(
threadId: string,
options: { signal?: AbortSignal } = {},
): Promise<SessionArtifactsResponse> {
const res = await apiFetch(
`${getBackendBaseURL()}/api/threads/${encodeURIComponent(threadId)}/artifacts`,
{ method: "GET", signal: options.signal },
);
if (!res.ok) {
const text = await res.text().catch(() => "");
throw new Error(`list artifacts failed (${res.status}): ${text}`);
}
const json = (await res.json()) as {
thread_id: string;
files: Array<{
path: string;
name: string;
size_bytes: number;
mime_type: string | null;
modified_at: string;
}>;
};
return {
threadId: json.thread_id,
files: (json.files ?? []).map((f) => ({
path: f.path,
name: f.name,
sizeBytes: f.size_bytes,
mimeType: f.mime_type,
modifiedAt: f.modified_at,
})),
};
}
/**
* Build a URL that previews (inline) or downloads (attachment) an artifact
* file. The `path` must be a virtual path returned by
* {@link listSessionArtifacts} (e.g. `mnt/user-data/outputs/foo.md`).
*/
export function buildArtifactDownloadUrl(
threadId: string,
virtualPath: string,
options: { download?: boolean } = {},
): string {
const segments = virtualPath.split("/").map((s) => encodeURIComponent(s)).join("/");
const base = `${getBackendBaseURL()}/api/threads/${encodeURIComponent(threadId)}/artifacts/${segments}`;
return options.download ? `${base}?download=true` : base;
}