@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.11

package/dist/worker/console/static-src/operator-chat/details-dag-actions.js

@@ -0,0 +1,122 @@
+function resolveDagId(id) {
+    const value = typeof id === "function" ? id() : id;
+    return value?.trim() || null;
+}
+export function createDetailsDagActions(params) {
+    const fetchImpl = params.fetchFn ?? fetch;
+    let pending = false;
+    let error = null;
+    const completionListeners = new Set();
+    const emitState = () => params.onStateChange?.({ pending, error });
+    const emitCompletion = (outcome, identity, message) => {
+        for (const listener of [...completionListeners]) {
+            try {
+                listener(outcome, identity, message);
+            }
+            catch {
+                // a listener throwing must never break the request path
+            }
+        }
+    };
+    const run = (action, issue) => {
+        const sessionId = resolveDagId(params.sessionId);
+        const operationId = resolveDagId(params.operationId);
+        if (!sessionId || !operationId || pending)
+            return false;
+        const identity = {
+            action,
+            workspaceId: resolveDagId(params.workspaceId ?? null),
+            sessionId,
+            operationId,
+        };
+        pending = true;
+        error = null;
+        emitState();
+        void (async () => {
+            try {
+                const result = await issue(identity);
+                if (!result.ok) {
+                    error = result.message ?? `DAG 关联操作失败`;
+                    params.onFailure?.(identity, error);
+                    emitCompletion("failure", identity, error);
+                    return;
+                }
+                params.onSuccess?.(identity);
+                emitCompletion("success", identity);
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                params.onFailure?.(identity, error);
+                emitCompletion("failure", identity, error);
+            }
+            finally {
+                pending = false;
+                emitState();
+            }
+        })();
+        return true;
+    };
+    return {
+        get pending() {
+            return pending;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            completionListeners.add(listener);
+            return () => completionListeners.delete(listener);
+        },
+        onAddDag() {
+            return run("add", async (identity) => {
+                // AC-002: session-scoped mutations carry the session's durable
+                // owning workspace so a global active-workspace switch can never
+                // retarget the link to another workspace's store.
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links${ownerQuery}`, {
+                    method: "POST",
+                    credentials: "same-origin",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                    body: JSON.stringify({ operationId: identity.operationId }),
+                });
+                if (!res.ok) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `添加 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+        onRemoveDag() {
+            return run("remove", async (identity) => {
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links/${encodeURIComponent(identity.operationId)}${ownerQuery}`, {
+                    method: "DELETE",
+                    credentials: "same-origin",
+                    headers: {
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                });
+                if (!res.ok && res.status !== 404) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `移除 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+    };
+}

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

@@ -24,6 +24,7 @@ export function useChatRefs() {
     const abortPostedTurnIdsRef = useRef(new Set());
     const releasedClientRequestIdsRef = useRef(new Set());
     const usageResponseKeysRef = useRef(new Set());
+    const unlinkedOperationIdsRef = useRef(new Map());
     const isComposingRef = useRef(false);
     const compositionEndedAtRef = useRef(0);
     // Keep the bag identity stable: individual refs never change, so domain
@@ -53,6 +54,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     }), [
@@ -80,6 +82,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     ]);

package/dist/worker/console/static-src/operator-chat/runtime-selection-labels.js

@@ -0,0 +1,27 @@
+import { formatModelRef } from "../../chat/runtime-selection.js";
+const THINKING_SHORT_LABELS = {
+    auto: "Auto",
+    off: "Off",
+    minimal: "Minimal",
+    low: "Low",
+    medium: "Medium",
+    high: "High",
+    xhigh: "XHigh",
+    max: "Max",
+};
+export function formatThinkingSelectionLabel(selection, effective) {
+    const normalized = selection || "auto";
+    const label = THINKING_SHORT_LABELS[normalized] ?? normalized;
+    if (normalized !== "auto" || !effective)
+        return label;
+    return `${label} · ${THINKING_SHORT_LABELS[effective] ?? effective}`;
+}
+export function resolveModelDisplayName(models, activeModelRef) {
+    if (!activeModelRef)
+        return "选择模型";
+    const current = models.find((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    if (current)
+        return current.name?.trim() || current.id;
+    const slash = activeModelRef.indexOf("/");
+    return slash === -1 ? activeModelRef : activeModelRef.slice(slash + 1);
+}

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

@@ -1,6 +1,6 @@
 /**
  * Mutual-exclusion state for large spatial overlays in Operator Chat.
- * At most one of: sidebar drawer, process, runtime context, tools, activity.
+ * At most one of: sidebar drawer, process, runtime context, tools.
  * Small composer menus (model/thinking) are out of scope.
  */
 export function createSpatialOverlayState(active = "none") {
@@ -33,6 +33,5 @@ export function spatialOverlayFlags(state) {
         processOpen: state.active === "process",
         runtimeContextOpen: state.active === "runtime-context",
         toolsOpen: state.active === "tools",
-        activityOpen: state.active === "activity",
     };
 }

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -38,6 +38,15 @@ export function turnPhaseFromOwnership(bag) {
         return "running";
     return "idle";
 }
+/**
+ * DSH-style visual projection: Stop immediately releases the composer while
+ * the ownership projection remains `stopping` for deferred-send routing and
+ * duplicate-Turn prevention.
+ */
+export function visualTurnPhaseFromOwnership(bag) {
+    const phase = turnPhaseFromOwnership(bag);
+    return phase === "stopping" ? "idle" : phase;
+}
 export function createTurnOwnershipBag(seed) {
     return {
         submitInFlight: false,
@@ -394,6 +403,9 @@ export function classifyAbortResponse(input) {
         isTerminalTurnState(terminalState)) {
         return { action: "terminal-idle", turnId: input.turnId };
     }
+    if (input.httpOk && input.body.accepted === true) {
+        return { action: "abort-accepted-background" };
+    }
     if (input.body.error?.code === "TURN_ABORT_PENDING") {
         return { action: "abort-pending-notice" };
     }
@@ -416,6 +428,10 @@ export function applyAbortDecision(bag, decision, notice, opts) {
         if (!current)
             return;
         bag.settledTurnIds.add(decision.turnId);
+        if (bag.pendingSubmission) {
+            releaseSubmitOwnership(bag, bag.pendingSubmission.clientRequestId);
+        }
+        clearStopRequested(bag);
         bag.streaming = false;
         bag.activeTurnId = null;
         bag.assistantId = null;
@@ -423,6 +439,11 @@ export function applyAbortDecision(bag, decision, notice, opts) {
         opts?.markIdle?.();
         return;
     }
+    if (decision.action === "abort-accepted-background") {
+        // Visual idle is projected by the caller. Hidden ownership deliberately
+        // remains stopping until terminal SSE or /state evidence releases it.
+        return;
+    }
     if (decision.action === "abort-pending-notice") {
         // Non-fatal; keep busy.
         notice.showNotice(ABORT_PENDING_NOTICE);
@@ -436,6 +457,10 @@ export function applyAbortDecision(bag, decision, notice, opts) {
                 bag.settledTurnIds.add(bag.stoppingTurnId);
             }
             bag.streaming = false;
+            if (bag.pendingSubmission) {
+                releaseSubmitOwnership(bag, bag.pendingSubmission.clientRequestId);
+            }
+            clearStopRequested(bag);
             bag.activeTurnId = null;
             bag.assistantId = null;
             bag.stoppingTurnId = null;

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

@@ -40,8 +40,9 @@ export function reconcileDeferredSubmissionFromState(input) {
     const { clientRequestId, blockedByTurnId, state } = input;
     if (!state)
         return { action: "hold" };
-    if (state.deferredTurn?.clientRequestId === clientRequestId) {
-        return { action: "deferred", deferredTurn: state.deferredTurn };
+    const queued = state.deferredTurns?.find((item) => item.clientRequestId === clientRequestId) ?? (state.deferredTurn?.clientRequestId === clientRequestId ? state.deferredTurn : undefined);
+    if (queued) {
+        return { action: "deferred", deferredTurn: queued };
     }
     if (state.activeTurn?.clientRequestId === clientRequestId) {
         return { action: "accepted", turn: state.activeTurn };