功能说明:\n- 为写文件工具链增加流式预览状态模型(in-flight、chunk 归并、已完成)\n- 在消息面板中支持 write_file 流式 artifact 的动态插入/更新与完成态呈现\n- 优化 artifact 详情页的文件名与来源显示,兼容流式生成中文件路径\n- 在 Roundtable 工作流 step2 流程中注入与监听 write_file 事件,支持多阶段消息统一展示\n- 补充单测覆盖:streaming-write-preview、write-file-in-flight、streaming-artifacts 等关键路径
145 lines
5.3 KiB
TypeScript
145 lines
5.3 KiB
TypeScript
import {
|
|
hasCompleteArtifactExtension,
|
|
languageOfStreamingArtifact,
|
|
normalizeStreamingArtifactPath,
|
|
provisionalWriteFilePath,
|
|
} from "@/core/artifacts/streaming-write-preview";
|
|
|
|
/**
|
|
* Resolve the path that may be live-previewed while a roundtable tool call is
|
|
* still streaming.
|
|
*
|
|
* `write_file` is deliberately unrestricted here: the sandbox is a live tool
|
|
* activity view, not the final-deliverable list. Agents commonly write a
|
|
* temporary Python script before reading a skill or running it; suppressing
|
|
* that preview makes the page look stalled even though the backend is busy.
|
|
* The separate `collectRoundtableDeliverablePaths` gate remains responsible
|
|
* for limiting message-list file cards to Markdown, HTML, and Mermaid.
|
|
*
|
|
* `str_replace` retains its existing document-only behavior. It has no full
|
|
* content payload for a virtual preview, and is not a new-file write.
|
|
*/
|
|
export function resolveRoundtableStreamingWritePreview(
|
|
toolName: string | undefined,
|
|
args: Record<string, unknown> | undefined,
|
|
): string | null {
|
|
const rawPath = typeof args?.path === "string" ? args.path : "";
|
|
const path = normalizeStreamingArtifactPath(rawPath);
|
|
if (toolName === "write_file") {
|
|
// Weak models can emit content before the `path` JSON key. Give that same
|
|
// call a temporary name so the sandbox opens and continues receiving data.
|
|
const content = typeof args?.content === "string" ? args.content : "";
|
|
// A complete path of *any* file type is previewable. Keep an incomplete
|
|
// suffix such as `report.m` provisional while content is already flowing,
|
|
// so it upgrades cleanly to Markdown once the final `d` arrives.
|
|
if (path && (hasCompleteArtifactExtension(path) || !content.trim())) {
|
|
return path;
|
|
}
|
|
return content.trim() ? provisionalWriteFilePath(content) : null;
|
|
}
|
|
|
|
// Preserve the prior, conservative behavior for in-place replacement.
|
|
return languageOfStreamingArtifact(path) ? path : null;
|
|
}
|
|
|
|
/**
|
|
* Merge successive snapshots of one streaming tool call without losing bytes
|
|
* that arrived in an earlier SSE frame.
|
|
*
|
|
* LangChain's partial JSON snapshots frequently contain only `path` while the
|
|
* complete `content` has already been received (and the inverse can happen
|
|
* while the path key is still incomplete). A click on a progress step also
|
|
* carries the deliberately compact `{ path }` payload. Blindly replacing the
|
|
* prior args with either shape empties the virtual write_file preview.
|
|
*/
|
|
export function mergeRoundtableStreamingToolArgs(
|
|
previous: Record<string, unknown> | undefined,
|
|
incoming: Record<string, unknown>,
|
|
): Record<string, unknown> {
|
|
if (!previous) return { ...incoming };
|
|
|
|
const merged = { ...previous, ...incoming };
|
|
for (const key of ["path", "content"] as const) {
|
|
const prior = previous[key];
|
|
const next = incoming[key];
|
|
if (
|
|
typeof prior === "string" &&
|
|
prior.length > 0 &&
|
|
!(typeof next === "string" && next.length > 0)
|
|
) {
|
|
merged[key] = prior;
|
|
}
|
|
}
|
|
return merged;
|
|
}
|
|
|
|
/** Final artifact cards intentionally expose only user-facing deliverables. */
|
|
export function collectRoundtableDeliverablePaths(values: Iterable<unknown>): string[] {
|
|
const seen = new Set<string>();
|
|
const paths: string[] = [];
|
|
for (const value of values) {
|
|
if (typeof value !== "string") continue;
|
|
const path = normalizeStreamingArtifactPath(value);
|
|
if (!path || !languageOfStreamingArtifact(path) || seen.has(path)) continue;
|
|
seen.add(path);
|
|
paths.push(path);
|
|
}
|
|
return paths;
|
|
}
|
|
|
|
export interface RoundtableWatchedArtifact {
|
|
path: string;
|
|
sizeBytes: number;
|
|
modifiedAt: string;
|
|
}
|
|
|
|
/** Stable disk signature used to notice both newly created and overwritten files. */
|
|
export function roundtableArtifactDiskSnapshot(
|
|
files: Iterable<RoundtableWatchedArtifact>,
|
|
): Map<string, string> {
|
|
const snapshot = new Map<string, string>();
|
|
for (const file of files) {
|
|
const path = normalizeStreamingArtifactPath(file.path);
|
|
if (!path) continue;
|
|
snapshot.set(path, `${file.sizeBytes}:${file.modifiedAt}`);
|
|
}
|
|
return snapshot;
|
|
}
|
|
|
|
/**
|
|
* Pick the newest file created or changed since the prior directory poll.
|
|
*
|
|
* On the first poll there is no baseline yet. A small grace window catches a
|
|
* skill output that lands between mounting the streaming bubble and the first
|
|
* HTTP response, without reopening unrelated files from older roundtable runs.
|
|
*/
|
|
export function newestChangedRoundtableArtifact(
|
|
files: readonly RoundtableWatchedArtifact[],
|
|
previous: ReadonlyMap<string, string> | undefined,
|
|
watchStartedAtMs: number,
|
|
firstPollGraceMs = 2_000,
|
|
): RoundtableWatchedArtifact | null {
|
|
let newest: RoundtableWatchedArtifact | null = null;
|
|
let newestTime = Number.NEGATIVE_INFINITY;
|
|
|
|
for (const file of files) {
|
|
const path = normalizeStreamingArtifactPath(file.path);
|
|
if (!path) continue;
|
|
const signature = `${file.sizeBytes}:${file.modifiedAt}`;
|
|
const modifiedTime = Date.parse(file.modifiedAt);
|
|
const changed = previous
|
|
? previous.get(path) !== signature
|
|
: Number.isFinite(modifiedTime) &&
|
|
modifiedTime >= watchStartedAtMs - firstPollGraceMs;
|
|
if (!changed) continue;
|
|
|
|
const sortableTime = Number.isFinite(modifiedTime) ? modifiedTime : 0;
|
|
if (!newest || sortableTime > newestTime) {
|
|
newest = { ...file, path };
|
|
newestTime = sortableTime;
|
|
}
|
|
}
|
|
|
|
return newest;
|
|
}
|