@tea-agent/loop-agent 0.43.0-next.8 → 0.43.0

package/dist/worker/console/static-src/operator-chat/composer-session-ledger.js

@@ -0,0 +1,192 @@
+import { createInputHistoryState, navigateInputHistory, recordInputHistoryEntry, resetInputHistoryBrowsing, } from "./input-history.js";
+export const DUPLICATE_SUBMISSION_GESTURE_MS = 350;
+export function composerSessionKey(identity) {
+    return `${identity.workspaceId ?? ""}\u0000${identity.sessionId}`;
+}
+function cloneHistory(history) {
+    return { ...history, entries: [...history.entries] };
+}
+function cloneImages(images) {
+    return [...images];
+}
+function createRecord() {
+    return {
+        draft: "",
+        images: [],
+        history: createInputHistoryState(),
+        revision: 0,
+        sequence: 0,
+        initialized: false,
+        attempts: new Map(),
+        failedSubmissionCount: 0,
+    };
+}
+function sameImages(left, right) {
+    return (left.length === right.length &&
+        left.every((image, index) => {
+            const other = right[index];
+            return (other !== undefined &&
+                image.name === other.name &&
+                image.type === other.type &&
+                image.mimeType === other.mimeType &&
+                image.data === other.data);
+        }));
+}
+/**
+ * Browser-local composer state addressed by durable session identity.
+ *
+ * Network callbacks settle immutable attempts against their owning record;
+ * they never need to mutate whichever composer happens to be visible.
+ */
+export class ComposerSessionLedger {
+    now;
+    records = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    has(identity) {
+        return this.records.has(composerSessionKey(identity));
+    }
+    snapshot(identity) {
+        const record = this.record(identity);
+        return {
+            draft: record.draft,
+            images: cloneImages(record.images),
+            history: cloneHistory(record.history),
+            revision: record.revision,
+            failedSubmissionCount: record.failedSubmissionCount,
+        };
+    }
+    seedDraft(identity, draft) {
+        const record = this.record(identity);
+        if (record.initialized || record.revision !== 0 || record.attempts.size > 0)
+            return false;
+        record.draft = draft;
+        record.initialized = true;
+        return true;
+    }
+    setDraft(identity, draft) {
+        const record = this.record(identity);
+        if (record.draft === draft)
+            return false;
+        record.draft = draft;
+        record.history = resetInputHistoryBrowsing(record.history);
+        record.revision += 1;
+        record.initialized = true;
+        return true;
+    }
+    setImages(identity, images) {
+        const record = this.record(identity);
+        record.images = cloneImages(images);
+        record.revision += 1;
+        record.initialized = true;
+        return true;
+    }
+    recordHistory(identity, text) {
+        const record = this.record(identity);
+        record.history = recordInputHistoryEntry(record.history, text);
+    }
+    navigateHistory(identity, direction, context) {
+        const record = this.record(identity);
+        const decision = navigateInputHistory(record.history, direction, context);
+        if (!decision.handled)
+            return decision;
+        record.history = decision.state;
+        if (record.draft !== decision.text) {
+            record.draft = decision.text;
+            record.revision += 1;
+            record.initialized = true;
+        }
+        return decision;
+    }
+    beginSubmission(identity, sessionGeneration, clientRequestId) {
+        const record = this.record(identity);
+        if (!record.draft.trim() && record.images.length === 0)
+            return null;
+        const now = this.now();
+        const sinceLastClaim = record.lastClaim
+            ? now - record.lastClaim.at
+            : Number.POSITIVE_INFINITY;
+        if (record.lastClaim &&
+            sinceLastClaim >= 0 &&
+            sinceLastClaim <= DUPLICATE_SUBMISSION_GESTURE_MS &&
+            record.lastClaim.draft === record.draft &&
+            sameImages(record.lastClaim.images, record.images))
+            return null;
+        record.sequence += 1;
+        const sequence = record.sequence;
+        const controller = new AbortController();
+        const draftSnapshot = record.draft;
+        const imageSnapshot = cloneImages(record.images);
+        record.lastClaim = {
+            draft: draftSnapshot,
+            images: cloneImages(imageSnapshot),
+            at: now,
+        };
+        record.history = recordInputHistoryEntry(record.history, draftSnapshot);
+        record.draft = "";
+        record.images = [];
+        record.revision += 1;
+        record.initialized = true;
+        const attempt = {
+            attemptId: `${composerSessionKey(identity)}:${sequence}:${clientRequestId}`,
+            identity: { ...identity },
+            sessionGeneration,
+            sequence,
+            clientRequestId,
+            draftSnapshot,
+            imageSnapshot,
+            committedRevision: record.revision,
+            signal: controller.signal,
+        };
+        record.attempts.set(attempt.attemptId, { attempt, controller });
+        return attempt;
+    }
+    settle(attempt, outcome) {
+        const key = composerSessionKey(attempt.identity);
+        const record = this.records.get(key);
+        const owned = record?.attempts.get(attempt.attemptId);
+        if (!record || !owned || owned.attempt !== attempt)
+            return "stale";
+        record.attempts.delete(attempt.attemptId);
+        owned.controller.abort();
+        if (outcome === "accepted")
+            return "accepted";
+        if (record.revision === attempt.committedRevision &&
+            record.draft === "" &&
+            record.images.length === 0) {
+            record.draft = attempt.draftSnapshot;
+            record.images = cloneImages(attempt.imageSnapshot);
+            record.revision += 1;
+            return "restored";
+        }
+        record.failedSubmissionCount = Math.min(Number.MAX_SAFE_INTEGER, record.failedSubmissionCount + 1);
+        return "retained";
+    }
+    settleByRequest(identity, clientRequestId, outcome) {
+        const record = this.records.get(composerSessionKey(identity));
+        const owned = record
+            ? [...record.attempts.values()].find((entry) => entry.attempt.clientRequestId === clientRequestId)
+            : undefined;
+        return owned ? this.settle(owned.attempt, outcome) : "stale";
+    }
+    release(identity) {
+        const key = composerSessionKey(identity);
+        const record = this.records.get(key);
+        if (!record)
+            return;
+        for (const owned of record.attempts.values())
+            owned.controller.abort();
+        record.attempts.clear();
+        this.records.delete(key);
+    }
+    record(identity) {
+        const key = composerSessionKey(identity);
+        let record = this.records.get(key);
+        if (!record) {
+            record = createRecord();
+            this.records.set(key, record);
+        }
+        return record;
+    }
+}

package/dist/worker/console/static-src/operator-chat/pending-user-message.js

@@ -27,7 +27,15 @@ export function replacePendingUserMessage(messages, clientRequestId, durable) {
             continue;
         replaced = true;
         const { pending: _pending, ...rest } = message;
-        next.push({ ...rest, ...durable, clientRequestId });
+        next.push({
+            ...rest,
+            ...durable,
+            // Durable reconciliation replaces values in the established optimistic
+            // seat. A later server timestamp must not move the user below the empty
+            // active assistant cursor when turn groups sort by display time.
+            createdAt: Math.min(message.createdAt, durable.createdAt),
+            clientRequestId,
+        });
     }
     return replaced ? next : [...next, durable];
 }

package/dist/worker/console/static-src/operator-chat/slash-palette-nav.js

@@ -27,8 +27,11 @@ export function buildPaletteModel(entries) {
     for (const source of SLASH_GROUP_DISPLAY_ORDER) {
         const items = [];
         for (let i = 0; i < entries.length; i += 1) {
-            if (entries[i].source === source) {
-                items.push({ entry: entries[i], globalIndex: i });
+            const entry = entries[i];
+            if (!entry)
+                continue;
+            if (entry.source === source) {
+                items.push({ entry, globalIndex: i });
             }
         }
         if (items.length === 0)
@@ -69,6 +72,8 @@ export function movePaletteIndex(currentIndex, model, columns, direction) {
     if (groupPos < 0)
         return currentIndex;
     const group = model[groupPos];
+    if (!group)
+        return currentIndex;
     const offset = group.items.findIndex((card) => card.globalIndex === currentIndex);
     if (offset < 0)
         return currentIndex;
@@ -84,25 +89,30 @@ export function movePaletteIndex(currentIndex, model, columns, direction) {
         }
         if (Math.floor(targetOffset / columns) !== row)
             return currentIndex;
-        return group.items[targetOffset].globalIndex;
+        const targetCard = group.items[targetOffset];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     const delta = direction === "up" ? -1 : 1;
     const targetOffset = offset + delta * columns;
     if (targetOffset >= 0 && targetOffset < group.items.length) {
-        return group.items[targetOffset].globalIndex;
+        const targetCard = group.items[targetOffset];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     // Cross-group: walk to the previous/next non-empty group and target the
     // same column on its last (up) / first (down) row; stick when that column
     // does not exist in the partial edge row.
     for (let cursor = groupPos + delta; cursor >= 0 && cursor < model.length; cursor += delta) {
         const candidate = model[cursor];
+        if (!candidate)
+            continue;
         if (candidate.items.length === 0)
             continue;
         const lastRowStart = Math.floor((candidate.items.length - 1) / columns) * columns;
         const target = direction === "up" ? lastRowStart + col : col;
         if (target >= candidate.items.length)
             return currentIndex;
-        return candidate.items[target].globalIndex;
+        const targetCard = candidate.items[target];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     return currentIndex;
 }

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

@@ -0,0 +1,29 @@
+function anchorAt(group) {
+    return group.user?.createdAt ?? group.assistants[0]?.createdAt ?? 0;
+}
+function pendingAt(item) {
+    const at = Date.parse(item.updatedAt);
+    return Number.isFinite(at) ? at : Number.MAX_SAFE_INTEGER;
+}
+/**
+ * Merge pending (dispatching/queued) user steering into the message timeline
+ * by timestamp instead of always rendering at the very end. A pending message
+ * whose `updatedAt` precedes an already-rendered turn keeps its real slot; a
+ * stable sort preserves current group order for equal anchors (turns first).
+ */
+export function mergePendingIntoTimeline(input) {
+    const entries = [];
+    for (const group of input.turnGroups) {
+        entries.push({ kind: "group", group });
+    }
+    for (const item of input.pendingSteering) {
+        if (item.state !== "dispatching")
+            continue;
+        entries.push({ kind: "pending", item });
+    }
+    return entries.sort((a, b) => {
+        const atA = a.kind === "group" ? anchorAt(a.group) : pendingAt(a.item);
+        const atB = b.kind === "group" ? anchorAt(b.group) : pendingAt(b.item);
+        return atA - atB;
+    });
+}

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

@@ -0,0 +1,10 @@
+export function turnProcessDisclosureKey(groupKey, answerId) {
+    return `${groupKey}:generation-${answerId ?? "none"}`;
+}
+export function isTurnProcessCompact(input) {
+    return (!input.historyHasMore &&
+        !input.live &&
+        !input.hasError &&
+        input.processItemCount > 0 &&
+        !input.expanded);
+}