@tea-agent/loop-agent 0.34.2 → 0.34.4

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

@@ -0,0 +1,158 @@
+/**
+ * Pure Turn submission / response protocol helpers for Operator Chat.
+ * Extracted so double-submit, TURN_ACTIVE adoption, transport ambiguity, and
+ * generation fences can be unit-tested without mounting the full React tree.
+ */
+export function createPendingSubmission(input) {
+    let resolveOutcome;
+    const outcomePromise = new Promise((resolve) => {
+        resolveOutcome = resolve;
+    });
+    return {
+        ...input,
+        outcomePromise,
+        resolveOutcome,
+    };
+}
+/** Transport / network failure while creating a Turn — never a definitive rejection. */
+export function classifyCreateTurnNetworkFailure(message = "network error while creating turn") {
+    return { kind: "ambiguous", message };
+}
+/**
+ * After the same-clientRequestId POST retry still lacks definitive acceptance,
+ * stay ambiguous so the client keeps busy ownership and continues /state reconcile.
+ * Must never promote transport uncertainty to rejected (would forge idle).
+ */
+export function keepAmbiguousAfterRetry(message = "无法确认 Turn 是否已创建，正在与服务端对账（不会重复提交新的请求 ID）") {
+    return { kind: "ambiguous", message };
+}
+/** Classify a POST /turns HTTP response into a submission outcome. */
+export function classifyCreateTurnResponse(input) {
+    const { body, clientRequestId } = input;
+    const errorCode = body.error?.code;
+    const errorMessage = body.error?.message ??
+        (input.httpOk ? "turn was not accepted" : `HTTP ${input.status}`);
+    if (errorCode === "TURN_ACTIVE" && body.activeTurn?.turnId) {
+        return {
+            kind: "adopt-active",
+            activeTurn: body.activeTurn,
+            message: "上一轮仍在运行，已重新连接；当前消息已保留。",
+        };
+    }
+    if (body.accepted === true || (input.httpOk && body.turnId)) {
+        const turnId = body.turn?.turnId ?? body.turnId;
+        if (!turnId) {
+            return { kind: "ambiguous", message: errorMessage };
+        }
+        return {
+            kind: "accepted",
+            turnId,
+            idempotent: body.idempotent === true,
+            turn: body.turn ?? {
+                turnId,
+                clientRequestId,
+                state: body.state,
+            },
+        };
+    }
+    if (body.accepted === false || errorCode) {
+        return {
+            kind: "rejected",
+            code: errorCode,
+            message: errorMessage,
+        };
+    }
+    // Transport-level uncertainty: no definitive acceptance flag.
+    return { kind: "ambiguous", message: errorMessage };
+}
+/** Resolve an ambiguous POST via GET /state using clientRequestId. */
+export function resolveAmbiguousFromState(input) {
+    const clientRequestId = input.clientRequestId;
+    const active = input.state?.activeTurn;
+    const latest = input.state?.latestTurn;
+    if (active?.clientRequestId === clientRequestId && active.turnId) {
+        return {
+            kind: "accepted",
+            turnId: active.turnId,
+            idempotent: true,
+            turn: active,
+        };
+    }
+    if (latest?.clientRequestId === clientRequestId && latest.turnId) {
+        return {
+            kind: "accepted",
+            turnId: latest.turnId,
+            idempotent: true,
+            turn: latest,
+        };
+    }
+    if (active?.turnId) {
+        return {
+            kind: "adopt-active",
+            activeTurn: active,
+            message: "上一轮仍在运行，已重新连接；当前消息已保留。",
+        };
+    }
+    return null;
+}
+export function reconcilePendingSubmissionFromState(input) {
+    const clientRequestId = input.clientRequestId;
+    const active = input.state?.activeTurn;
+    const latest = input.state?.latestTurn;
+    const activeState = active?.state ?? input.state?.activeTurnState ?? undefined;
+    const latestState = latest?.state ?? input.state?.latestTurnState ?? undefined;
+    if (active?.clientRequestId === clientRequestId && active.turnId) {
+        if (isTerminalTurnState(activeState)) {
+            return {
+                action: "release-terminal",
+                turnId: active.turnId,
+                state: String(activeState),
+            };
+        }
+        return { action: "bind-active", turnId: active.turnId };
+    }
+    if (latest?.clientRequestId === clientRequestId && latest.turnId) {
+        if (isTerminalTurnState(latestState)) {
+            return {
+                action: "release-terminal",
+                turnId: latest.turnId,
+                state: String(latestState),
+            };
+        }
+        // Non-terminal match on latest without a conflicting foreign active:
+        // bind and keep busy ownership (same clientRequestId, no re-POST).
+        if (!active?.turnId || active.clientRequestId === clientRequestId) {
+            return { action: "bind-active", turnId: latest.turnId };
+        }
+    }
+    // Explicit non-acceptance: no same-id Turn and runtime not busy.
+    // Do not forge idle while durable/runtime still reports busy.
+    if (!isRuntimeBusyUnion(input.state)) {
+        const foreignActive = Boolean(active?.turnId) && active?.clientRequestId !== clientRequestId;
+        if (!foreignActive) {
+            return { action: "release-not-accepted" };
+        }
+    }
+    return { action: "hold" };
+}
+/** Busy truth = durable active Turn ∪ runtime busy facts. */
+export function isRuntimeBusyUnion(state) {
+    if (state?.activeTurnId || state?.activeTurn?.turnId)
+        return true;
+    const runtime = state?.runtime;
+    if (!runtime)
+        return false;
+    return (runtime.isStreaming === true ||
+        runtime.isPromptRunning === true ||
+        runtime.isCompacting === true ||
+        runtime.isBashRunning === true);
+}
+export function isTerminalTurnState(state) {
+    return state === "settled" || state === "aborted" || state === "failed";
+}
+/** Whether a late response may mutate the current session UI. */
+export function isSubmissionCurrent(input) {
+    return (input.pending.sessionId === input.sessionId &&
+        input.pending.sessionGeneration === input.sessionGeneration &&
+        input.pending.submitGeneration === input.submitGeneration);
+}