@tea-agent/loop-agent 0.32.0 → 0.33.0

package/dist/worker/console/static-src/operator-chat/useRuntimeControls.js

@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { formatModelRef, mergeSessionRuntime, runtimeSelectionFromRecord, sessionRuntimeMatches, } from "../../chat/runtime-selection.js";
+import { confirmationToken } from "./format.js";
+import { buildToolCatalog } from "./tools-catalog.js";
+/** Capabilities catalog, model / thinking-level switcher, runtime-context
+ *  popover and the outside-click dismissal for both transient menus. */
+export function useRuntimeControls(params) {
+    const { origin, session, setSession, refs, setError } = params;
+    const [capabilities, setCapabilities] = useState(null);
+    const [models, setModels] = useState([]);
+    const [thinkingLevels, setThinkingLevels] = useState([]);
+    const [runtimeContext, setRuntimeContext] = useState(null);
+    const [toolsOpen, setToolsOpen] = useState(false);
+    const [runtimeContextOpen, setRuntimeContextOpen] = useState(false);
+    const toolsMenuRef = useRef(null);
+    const runtimeContextMenuRef = useRef(null);
+    const loadCapabilities = useCallback(async () => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/capabilities`);
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            setCapabilities(body);
+        }
+        catch {
+            // capabilities optional; Chat still works without them
+        }
+    }, [origin]);
+    useEffect(() => {
+        void loadCapabilities();
+    }, [loadCapabilities]);
+    useEffect(() => {
+        if (!session) {
+            setModels([]);
+            setRuntimeContext(null);
+            return;
+        }
+        const sessionId = session.sessionId;
+        const base = `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`;
+        void fetch(`${base}/models`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Guard against a stale response landing after the user switched/
+            // created/forked a session: only adopt models for the session we
+            // actually requested them for.
+            if (!body || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setModels(body.models ?? []);
+            setThinkingLevels(body.thinkingLevels ?? []);
+        });
+        void fetch(`${base}/runtime-context`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Stale-response guard: a slow runtime-context reply for session A
+            // must not overwrite the context/session state of the now-current
+            // session B.
+            if (!body?.context || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setRuntimeContext(body.context);
+            const ctx = body.context;
+            const patch = {
+                model: ctx.model,
+                thinkingLevel: ctx.thinkingLevel,
+            };
+            setSession((current) => {
+                if (!current || current.sessionId !== sessionId)
+                    return current;
+                if (sessionRuntimeMatches(current, patch))
+                    return current;
+                const merged = mergeSessionRuntime(current, patch);
+                refs.sessionRef.current = merged;
+                return merged;
+            });
+        });
+    }, [origin, session?.sessionId, refs, setSession]);
+    const switchRuntime = useCallback(async (body) => {
+        if (!session)
+            return;
+        // Capture the target session so a slow model/thinking response cannot
+        // write its result into a different (newly created/forked/switched)
+        // session the user has since moved to.
+        const targetSessionId = session.sessionId;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(session.sessionId)}/model`, {
+            method: "POST",
+            credentials: "include",
+            headers: {
+                "content-type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            // Only surface the failure for the session that still owns it.
+            if (refs.sessionRef.current?.sessionId === targetSessionId)
+                setError("模型或思考等级切换失败");
+            return;
+        }
+        const payload = (await res.json().catch(() => ({})));
+        if (!payload.session)
+            return;
+        // Drop the result entirely if the active session changed mid-flight.
+        if (refs.sessionRef.current?.sessionId !== targetSessionId)
+            return;
+        setSession((current) => {
+            if (!current || current.sessionId !== targetSessionId)
+                return current;
+            const patch = runtimeSelectionFromRecord(payload.session);
+            if (sessionRuntimeMatches(current, patch))
+                return current;
+            const merged = mergeSessionRuntime(current, patch);
+            refs.sessionRef.current = merged;
+            return merged;
+        });
+        setRuntimeContext((current) => current
+            ? {
+                ...current,
+                ...(payload.session.modelProvider && payload.session.modelId
+                    ? {
+                        model: {
+                            provider: payload.session.modelProvider,
+                            modelId: payload.session.modelId,
+                        },
+                    }
+                    : {}),
+                ...(payload.session.thinkingLevel
+                    ? { thinkingLevel: payload.session.thinkingLevel }
+                    : body.thinkingLevel
+                        ? { thinkingLevel: body.thinkingLevel }
+                        : {}),
+            }
+            : current);
+    }, [origin, session, refs, setSession, setError]);
+    // Close tools catalog on outside click / Escape.
+    useEffect(() => {
+        if (!toolsOpen)
+            return;
+        const onPointer = (e) => {
+            const root = toolsMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setToolsOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setToolsOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [toolsOpen]);
+    // Close runtime-context popover on outside click / Escape.
+    useEffect(() => {
+        if (!runtimeContextOpen)
+            return;
+        const onPointer = (e) => {
+            const root = runtimeContextMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setRuntimeContextOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setRuntimeContextOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [runtimeContextOpen]);
+    const toolCatalog = useMemo(() => buildToolCatalog(capabilities), [
+        capabilities,
+    ]);
+    const activeModel = session?.model ?? runtimeContext?.model;
+    const activeModelRef = activeModel
+        ? formatModelRef(activeModel.provider, activeModel.modelId)
+        : "";
+    const activeThinkingLevel = session?.thinkingLevel ?? runtimeContext?.thinkingLevel ?? "";
+    const activeModelListed = !activeModelRef ||
+        models.some((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    return {
+        capabilities,
+        models,
+        thinkingLevels,
+        runtimeContext,
+        toolsOpen,
+        setToolsOpen,
+        runtimeContextOpen,
+        setRuntimeContextOpen,
+        toolsMenuRef,
+        runtimeContextMenuRef,
+        switchRuntime,
+        toolCatalog,
+        activeModel,
+        activeModelRef,
+        activeThinkingLevel,
+        activeModelListed,
+    };
+}

package/dist/worker/observability/read-model.js

@@ -43,6 +43,11 @@ export function resolveLegacyTask(tasks, taskId) {
 }
 export const TASK_RUN_HISTORY_DEFAULT_LIMIT = 20;
 export const TASK_RUN_HISTORY_MAX_LIMIT = 100;
+/** Default / allowed page sizes for GET /api/dag-runs history list. */
+export const DAG_RUN_HISTORY_DEFAULT_PAGE = 1;
+export const DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE = 20;
+export const DAG_RUN_HISTORY_MAX_PAGE_SIZE = 100;
+export const DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES = [20, 50, 100];
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
 const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
 export async function buildGlobalSnapshot(options) {
@@ -227,6 +232,107 @@ export function clampTaskRunHistoryLimit(limit) {
     }
     return Math.min(Math.floor(limit), TASK_RUN_HISTORY_MAX_LIMIT);
 }
+export function clampDagRunHistoryPageSize(pageSize) {
+    if (pageSize === undefined || !Number.isFinite(pageSize) || pageSize <= 0) {
+        return DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE;
+    }
+    const floored = Math.floor(pageSize);
+    if (DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES.includes(floored)) {
+        return floored;
+    }
+    // Nearest allowed size, prefer smaller when equidistant, then clamp to max.
+    let best = DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const allowed of DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES) {
+        const dist = Math.abs(allowed - floored);
+        if (dist < bestDist || (dist === bestDist && allowed < best)) {
+            best = allowed;
+            bestDist = dist;
+        }
+    }
+    return Math.min(best, DAG_RUN_HISTORY_MAX_PAGE_SIZE);
+}
+export function clampDagRunHistoryPage(page, totalPages) {
+    const safeTotal = Math.max(1, Math.floor(totalPages) || 1);
+    if (page === undefined || !Number.isFinite(page) || page <= 0) {
+        return DAG_RUN_HISTORY_DEFAULT_PAGE;
+    }
+    return Math.min(Math.floor(page), safeTotal);
+}
+/**
+ * Formal DAG history membership (AC-004):
+ * exclude executionMode or lifecycle dry-run/init-only;
+ * keep missing executionMode when lifecycle is not a non-execution mode.
+ */
+export function isFormalDagRunHistoryCandidate(dag) {
+    const executionMode = (dag.executionMode ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(executionMode))
+        return false;
+    const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(lifecycle))
+        return false;
+    return true;
+}
+function dagRunHistorySortKey(dag) {
+    return `${dag.startedAt ?? dag.finishedAt ?? ""}\0${dag.dagRunId}`;
+}
+function projectDagRunHistoryProgress(dag) {
+    const nodes = dag.nodes ?? [];
+    let finished = 0;
+    for (const node of nodes) {
+        const status = (node.status ?? "").toLowerCase();
+        if (status === "finished" ||
+            status === "completed" ||
+            status === "succeeded" ||
+            status === "done" ||
+            status === "error" ||
+            status === "failed" ||
+            status === "skipped" ||
+            status === "partial_failed") {
+            finished += 1;
+        }
+    }
+    return { finished, total: nodes.length };
+}
+function toDagRunHistoryItem(dag) {
+    return {
+        dagRunId: dag.dagRunId,
+        ...(dag.title ? { title: dag.title } : {}),
+        ...(dag.status ? { status: dag.status } : {}),
+        ...(dag.effectiveStatus ? { effectiveStatus: dag.effectiveStatus } : {}),
+        ...(dag.lifecycle ? { lifecycle: dag.lifecycle } : {}),
+        ...(dag.executionMode ? { executionMode: dag.executionMode } : {}),
+        ...(dag.startedAt ? { startedAt: dag.startedAt } : {}),
+        ...(dag.finishedAt ? { finishedAt: dag.finishedAt } : {}),
+        ...(dag.durationMs !== undefined ? { durationMs: dag.durationMs } : {}),
+        progress: projectDagRunHistoryProgress(dag),
+    };
+}
+/**
+ * Paginated lightweight formal DAG run history from an in-memory GlobalSnapshot.
+ * Filters dry-run/init-only; sorts newest first; never embeds nodes/edges/previews.
+ */
+export function listDagRunHistoryFromSnapshot(snapshot, options = {}) {
+    const pageSize = clampDagRunHistoryPageSize(options.pageSize);
+    const formal = (snapshot.dagRuns ?? [])
+        .filter(isFormalDagRunHistoryCandidate)
+        .slice()
+        .sort((a, b) => dagRunHistorySortKey(b).localeCompare(dagRunHistorySortKey(a)));
+    const total = formal.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize) || 1);
+    const page = clampDagRunHistoryPage(options.page, totalPages);
+    const start = (page - 1) * pageSize;
+    const runs = formal.slice(start, start + pageSize).map(toDagRunHistoryItem);
+    return {
+        schemaVersion: 1,
+        generatedAt: snapshot.generatedAt,
+        page,
+        pageSize,
+        total,
+        totalPages,
+        runs,
+    };
+}
 function emptySnapshot(repoRoot, now) {
     let taskPoolPresent = false;
     try {

package/dist/worker/observe/routes.js

@@ -7,7 +7,7 @@ import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "../observability/events.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
 import { clampEventHistoryLimit, listBatchEventHistory, listPoolEventHistory, } from "../observability/event-history.js";
-import { buildGlobalSnapshot, clampTaskRunHistoryLimit, listTaskRunHistory, resolveLegacyTask, } from "../observability/read-model.js";
+import { buildGlobalSnapshot, clampDagRunHistoryPageSize, clampTaskRunHistoryLimit, listDagRunHistoryFromSnapshot, listTaskRunHistory, resolveLegacyTask, } from "../observability/read-model.js";
 import { loadDagRunExecutionTrajectory } from "../observability/dag-execution-trajectory.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
@@ -115,6 +115,13 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
         handler: handleDagRunById,
     },
+    // List route must be registered after /api/dag-runs/:id so detail keeps priority;
+    // matchObserveGetRoute scans in order and this path has no capture group.
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs$/,
+        handler: handleDagRuns,
+    },
     { method: "GET", pattern: /^\/api\/artifacts$/, handler: handleArtifactRead },
     {
         method: "GET",
@@ -507,6 +514,17 @@ async function handleRunArtifacts(_req, res, match, ctx) {
     }
     sendJson(res, 200, { artifacts });
 }
+/**
+ * GET /api/dag-runs?page=&pageSize=
+ * Lightweight formal DAG history page (schemaVersion 1).
+ */
+async function handleDagRuns(_req, res, match, ctx) {
+    const snapshot = await getSnapshot(ctx);
+    const page = parsePositiveInt(match.query.get("page"), 1);
+    const pageSize = clampDagRunHistoryPageSize(parsePositiveInt(match.query.get("pageSize"), 0) || undefined);
+    const body = listDagRunHistoryFromSnapshot(snapshot, { page, pageSize });
+    sendJson(res, 200, body);
+}
 export async function handleDagRunById(_req, res, match, ctx) {
     const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);

package/dist/worker/observe/static/api.js

@@ -13,10 +13,12 @@ export async function fetchJson(url) {
 /**
  * Read-only JSON fetch that preserves HTTP status so callers can distinguish
  * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
+ * Optional `signal` enables AbortController cancellation for formal navigation.
  */
-export async function fetchJsonResult(url) {
+export async function fetchJsonResult(url, options = {}) {
+	const signal = options?.signal;
 	try {
-		const res = await fetch(url);
+		const res = await fetch(url, signal ? { signal } : undefined);
 		let body = null;
 		try {
 			body = await res.json();
@@ -24,11 +26,48 @@ export async function fetchJsonResult(url) {
 			body = null;
 		}
 		return { ok: res.ok, status: res.status, body };
-	} catch {
+	} catch (err) {
+		if (
+			(err && (err.name === "AbortError" || err.code === 20)) ||
+			(signal && signal.aborted)
+		) {
+			return { ok: false, status: 0, body: null, aborted: true };
+		}
 		return { ok: false, status: 0, body: null };
 	}
 }
 
+/**
+ * Formal DAG history page (real request path). page/pageSize are query params.
+ * Callers should discard late responses via request generation tokens and may
+ * pass AbortSignal to cancel superseded formal navigation requests.
+ */
+export async function fetchDagRunHistory(page, pageSize, options = {}) {
+	const params = new URLSearchParams();
+	if (page != null) params.set("page", String(page));
+	if (pageSize != null) params.set("pageSize", String(pageSize));
+	const qs = params.toString();
+	const url = qs ? `/api/dag-runs?${qs}` : "/api/dag-runs";
+	return fetchJsonResult(url, options);
+}
+
+/**
+ * Safe user-facing error summary for DAG history (AC-015).
+ * Only local trusted fixed copy — never renders server error/message/detail
+ * or absolute local paths (Windows or POSIX).
+ */
+export function summarizeFetchError(result) {
+	if (!result) return "加载失败。";
+	if (result.status === 0) return "网络错误，请检查 Observe 服务是否可用。";
+	if (typeof result.status === "number" && result.status >= 500) {
+		return "服务暂时不可用，请稍后重试。";
+	}
+	if (typeof result.status === "number" && result.status >= 400) {
+		return "请求失败，请稍后重试。";
+	}
+	return "加载失败。";
+}
+
 /**
  * Fetch a dag node input projection. Preserves HTTP status so callers can
  * distinguish missing runs, unavailable nodes, and transport errors.

package/dist/worker/observe/static/app.js

@@ -49,6 +49,7 @@ import {
 import { renderFailures } from "./views/failures.js";
 import { startPoolView } from "./views/pool.js";
 import { startDashboardPolling } from "./views/dashboard.js";
+import { startDagsView } from "./views/dags.js";
 import { renderFeatureDetail } from "./views/feature.js";
 import { renderBatch } from "./views/batch.js";
 import { startTaskPolling } from "./views/task.js";
@@ -119,6 +120,8 @@ function route() {
 	const r = parseRoute();
 	if (r.view === "dashboard") {
 		startDashboardPolling(r.scrollTo);
+	} else if (r.view === "dags") {
+		void startDagsView();
 	} else if (r.view === "batch") {
 		void renderBatch(r.batchRunId);
 	} else if (r.view === "run") {
@@ -146,6 +149,7 @@ if (typeof window !== "undefined") {
 		if (!isPageVisible()) return;
 		const r = parseRoute();
 		if (r.view === "dashboard") startDashboardPolling();
+		// History page is manual-refresh only (no 5s dashboard polling).
 		if (r.view === "run") startRunPolling(r.workerRunId, false);
 		if (r.view === "dag") startDagPolling(r.dagRunId, false);
 		if (r.view === "pool" && uiState.poolAutoRefresh) startPoolView();

package/dist/worker/observe/static/constants.js

@@ -21,6 +21,8 @@ export const OUTPUT_FOLLOW_LATEST_PX = 48;
 export const UI_TEXT = {
 	dashboard: "总览",
 	dagRuns: "DAG 运行",
+	dagHistory: "DAG 运行历史",
+	viewAllDags: "查看全部 →",
 	failures: "异常 Task",
 	nightJobs: "夜间任务",
 	batchDetail: "批次详情",
@@ -31,6 +33,14 @@ export const UI_TEXT = {
 	batches: "Worker 批次",
 	noActiveDags: "当前没有进行中的 DAG，启动后将出现在这里。",
 	noRecentDags: "暂无 DAG 运行记录。",
+	noFormalDagHistory: "暂无正式 DAG 运行记录",
+	noFormalDagHistoryHint:
+		"dry-run / init-only 预检记录不会出现在此列表中。",
+	dagHistoryRefreshFailed: "刷新失败，当前展示上一次结果",
+	dagHistoryCopied: "已复制",
+	dagHistoryCopiedAnnounce: "已复制运行 ID",
+	dagHistoryCopyFailed: "复制失败，请手动选择运行 ID",
+	dagHistoryCopyTooltip: "复制运行 ID",
 	noBatches: "暂无 Worker 批次，运行后将出现在这里。",
 	noNodes: "暂无节点。",
 	noOutput: "暂无节点输出。",