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

package/dist/worker/console/chat/conversation-nodes.js

@@ -0,0 +1,383 @@
+function finiteStep(data) {
+    return typeof data.step === "number" && Number.isSafeInteger(data.step) && data.step >= 0
+        ? data.step
+        : undefined;
+}
+function locationFor(event, step = finiteStep(event.data)) {
+    return step === undefined
+        ? { kind: "turn", turnId: event.turnId }
+        : { kind: "step", turnId: event.turnId, step };
+}
+function status(value) {
+    return value === "scheduled" ||
+        value === "started" ||
+        value === "cancelled" ||
+        value === "running" ||
+        value === "completed" ||
+        value === "failed" ||
+        value === "interrupted"
+        ? value
+        : undefined;
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+        ? value
+        : undefined;
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function unknownRetryNode(event, base) {
+    return {
+        ...base,
+        key: `unknown:${event.eventId}`,
+        kind: "unknown",
+        location: locationFor(event),
+        data: {
+            eventType: "model_retry",
+            preview: "Incomplete model retry lifecycle event",
+        },
+    };
+}
+function retryStateFromEvent(data) {
+    if (data.state === "scheduled")
+        return "scheduled";
+    return data.success === false || data.state === "failed"
+        ? "cancelled"
+        : "started";
+}
+function isRetryAttempt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const attempt = value;
+    return (positiveInteger(attempt.attempt) !== undefined &&
+        positiveInteger(attempt.maxAttempts) !== undefined &&
+        nonNegativeNumber(attempt.delayMs) !== undefined &&
+        nonEmptyString(attempt.errorMessage) !== undefined &&
+        (attempt.state === "scheduled" ||
+            attempt.state === "started" ||
+            attempt.state === "cancelled") &&
+        typeof attempt.seq === "number" &&
+        typeof attempt.at === "number");
+}
+/** Read the current complete attempt from a projected retry-chain node. */
+export function modelRetryCurrent(node) {
+    if (node.kind !== "retry")
+        return undefined;
+    return isRetryAttempt(node.data.current) ? node.data.current : undefined;
+}
+function modelRetryAttempts(node) {
+    return Array.isArray(node.data.attempts)
+        ? node.data.attempts.filter(isRetryAttempt)
+        : [];
+}
+function retryUpdate(node) {
+    const value = node.data.retryUpdate;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (positiveInteger(candidate.attempt) === undefined ||
+        (candidate.state !== "started" && candidate.state !== "cancelled"))
+        return undefined;
+    return candidate;
+}
+/** Convert one already-redacted durable event into a stable UI node. */
+export function conversationNodeFromEvent(event) {
+    const at = Date.parse(event.at);
+    const base = {
+        anchorSeq: event.seq,
+        updatedSeq: event.seq,
+        at: Number.isFinite(at) ? at : 0,
+        data: event.data,
+    };
+    const step = finiteStep(event.data);
+    switch (event.kind) {
+        case "step_start":
+        case "step_end": {
+            if (step === undefined)
+                return undefined;
+            const outcome = status(event.data.outcome);
+            return {
+                ...base,
+                key: `step:${event.turnId}:${step}`,
+                kind: "step",
+                location: { kind: "step", turnId: event.turnId, step },
+                status: event.kind === "step_start" ? "running" : (outcome ?? "completed"),
+            };
+        }
+        case "model_retry": {
+            const attempt = positiveInteger(event.data.attempt);
+            if (attempt === undefined)
+                return unknownRetryNode(event, base);
+            const retryState = retryStateFromEvent(event.data);
+            const key = `retry:${event.turnId}:${step ?? 0}`;
+            if (retryState !== "scheduled") {
+                return {
+                    ...base,
+                    key,
+                    kind: "retry",
+                    location: locationFor(event),
+                    status: retryState,
+                    data: {
+                        retryUpdate: {
+                            attempt,
+                            state: retryState,
+                            seq: event.seq,
+                            at: base.at,
+                        },
+                    },
+                };
+            }
+            const maxAttempts = positiveInteger(event.data.maxAttempts);
+            const delayMs = nonNegativeNumber(event.data.delayMs);
+            const errorMessage = nonEmptyString(event.data.errorMessage);
+            if (maxAttempts === undefined || delayMs === undefined || !errorMessage) {
+                return unknownRetryNode(event, base);
+            }
+            const current = {
+                attempt,
+                maxAttempts,
+                delayMs,
+                errorMessage,
+                state: "scheduled",
+                seq: event.seq,
+                at: base.at,
+            };
+            return {
+                ...base,
+                key,
+                kind: "retry",
+                location: locationFor(event),
+                status: "scheduled",
+                data: { attempts: [current], current },
+            };
+        }
+        case "turn_error":
+            return {
+                ...base,
+                key: `turn-error:${event.turnId}`,
+                kind: "turn-error",
+                location: locationFor(event),
+                status: "failed",
+            };
+        case "turn_max_tokens":
+            return {
+                ...base,
+                key: `max-tokens:${event.turnId}:${step ?? 0}`,
+                kind: "max-tokens",
+                location: locationFor(event),
+                status: "completed",
+            };
+        case "request_context": {
+            const requestId = typeof event.data.requestId === "string" && event.data.requestId
+                ? event.data.requestId
+                : event.eventId;
+            return {
+                ...base,
+                key: `request:${requestId}`,
+                kind: "request",
+                location: locationFor(event),
+                status: "completed",
+            };
+        }
+        case "command": {
+            const commandId = typeof event.data.commandId === "string" && event.data.commandId
+                ? event.data.commandId
+                : event.eventId;
+            return {
+                ...base,
+                key: `command:${commandId}`,
+                kind: "command",
+                location: { kind: "turn", turnId: event.turnId },
+                status: status(event.data.outcome) ?? "completed",
+            };
+        }
+        case "unknown":
+            return {
+                ...base,
+                key: `unknown:${event.eventId}`,
+                kind: "unknown",
+                location: locationFor(event),
+            };
+    }
+}
+export function conversationNodesFromEvents(events) {
+    let nodes = [];
+    for (const event of events) {
+        const node = conversationNodeFromEvent(event);
+        if (node)
+            nodes = upsertConversationNode(nodes, node);
+    }
+    return nodes;
+}
+/** Keyed upsert that preserves the first structural anchor and location. */
+export function upsertConversationNode(nodes, next) {
+    if (next.kind === "retry")
+        return upsertRetryNode(nodes, next);
+    const merged = upsertBase(nodes, next);
+    if (next.kind === "step" && next.location.kind === "step") {
+        const { step: nextStep, turnId } = next.location;
+        if (next.status === "running") {
+            return transitionScheduledRetries(merged, (node) => node.location.kind === "step" &&
+                node.location.turnId === turnId &&
+                node.location.step < nextStep, "started", next.updatedSeq);
+        }
+        return transitionScheduledRetries(merged, (node) => node.location.kind === "step" &&
+            node.location.turnId === turnId &&
+            node.location.step === nextStep &&
+            node.anchorSeq < next.updatedSeq, "cancelled", next.updatedSeq);
+    }
+    if (next.kind === "turn-error") {
+        return transitionScheduledRetries(merged, (node) => node.location.kind !== "session" &&
+            next.location.kind !== "session" &&
+            node.location.turnId === next.location.turnId, "cancelled", next.updatedSeq);
+    }
+    return merged;
+}
+function upsertBase(nodes, next) {
+    const index = nodes.findIndex((node) => node.key === next.key);
+    if (index < 0) {
+        return [...nodes, next].sort((left, right) => left.anchorSeq - right.anchorSeq || left.key.localeCompare(right.key));
+    }
+    const previous = nodes[index];
+    if (next.updatedSeq < previous.updatedSeq)
+        return [...nodes];
+    const merged = {
+        ...previous,
+        ...next,
+        anchorSeq: previous.anchorSeq,
+        at: previous.at,
+        location: previous.location,
+        data: { ...previous.data, ...next.data },
+    };
+    const result = [...nodes];
+    result[index] = merged;
+    return result;
+}
+function retryTurnId(node) {
+    return node.location.kind === "session" ? undefined : node.location.turnId;
+}
+function retryCandidateIndex(nodes, next) {
+    const exact = nodes.findIndex((node) => node.key === next.key);
+    if (exact >= 0)
+        return exact;
+    const update = retryUpdate(next);
+    const nextCurrent = modelRetryCurrent(next);
+    const attempt = update?.attempt ?? nextCurrent?.attempt;
+    const turnId = retryTurnId(next);
+    if (attempt === undefined || !turnId)
+        return -1;
+    for (let index = nodes.length - 1; index >= 0; index -= 1) {
+        const candidate = nodes[index];
+        const current = modelRetryCurrent(candidate);
+        if (candidate.kind !== "retry" || retryTurnId(candidate) !== turnId || !current)
+            continue;
+        if (current.attempt === attempt)
+            return index;
+        if (nextCurrent?.state === "scheduled" && current.attempt + 1 === attempt)
+            return index;
+    }
+    return -1;
+}
+function upsertRetryNode(nodes, next) {
+    const index = retryCandidateIndex(nodes, next);
+    const nextCurrent = modelRetryCurrent(next);
+    const update = retryUpdate(next);
+    if (index < 0) {
+        if (nextCurrent)
+            return upsertBase(nodes, next);
+        return upsertBase(nodes, {
+            ...next,
+            key: `unknown:${next.key}:${next.updatedSeq}`,
+            kind: "unknown",
+            status: undefined,
+            data: {
+                eventType: "model_retry",
+                preview: "Orphan model retry lifecycle update",
+            },
+        });
+    }
+    const previous = nodes[index];
+    if (next.updatedSeq < previous.updatedSeq)
+        return [...nodes];
+    let attempts = modelRetryAttempts(previous);
+    if (nextCurrent) {
+        attempts = attempts.map((attempt) => attempt.state === "scheduled" && attempt.attempt < nextCurrent.attempt
+            ? { ...attempt, state: "started" }
+            : attempt);
+        const existing = attempts.findIndex((attempt) => attempt.attempt === nextCurrent.attempt);
+        if (existing >= 0)
+            attempts[existing] = { ...attempts[existing], ...nextCurrent };
+        else
+            attempts = [...attempts, nextCurrent];
+    }
+    else if (update) {
+        attempts = attempts.map((attempt) => attempt.attempt === update.attempt
+            ? { ...attempt, state: update.state }
+            : attempt);
+    }
+    const current = attempts.at(-1);
+    if (!current)
+        return [...nodes];
+    const result = [...nodes];
+    result[index] = {
+        ...previous,
+        updatedSeq: next.updatedSeq,
+        status: current.state,
+        data: { attempts, current },
+    };
+    return result;
+}
+function transitionScheduledRetries(nodes, predicate, state, updatedSeq) {
+    return nodes.map((node) => {
+        const current = modelRetryCurrent(node);
+        if (node.kind !== "retry" || current?.state !== "scheduled" || !predicate(node)) {
+            return node;
+        }
+        const attempts = modelRetryAttempts(node).map((attempt) => attempt.attempt === current.attempt
+            ? { ...attempt, state }
+            : attempt);
+        const nextCurrent = attempts.at(-1);
+        return {
+            ...node,
+            updatedSeq: Math.max(node.updatedSeq, updatedSeq),
+            status: state,
+            data: { attempts, current: nextCurrent },
+        };
+    });
+}
+/** Resolve explicit parent links only. Cycles and excessive chains fail flat. */
+export function toolNestingDepths(tools, maxDepth = 32) {
+    const byId = new Map(tools.map((tool) => [tool.id, tool]));
+    const depths = new Map();
+    const cyclic = new Set();
+    const resolve = (id, path) => {
+        const cached = depths.get(id);
+        if (cached !== undefined)
+            return cached;
+        const cycleAt = path.indexOf(id);
+        if (cycleAt >= 0) {
+            for (const key of path.slice(cycleAt))
+                cyclic.add(key);
+            return 0;
+        }
+        if (path.length >= maxDepth)
+            return 0;
+        const tool = byId.get(id);
+        const parent = tool?.parentToolCallId;
+        if (!parent || !byId.has(parent) || parent === id)
+            return 0;
+        const depth = Math.min(maxDepth, resolve(parent, [...path, id]) + 1);
+        return cyclic.has(id) ? 0 : depth;
+    };
+    for (const tool of tools)
+        depths.set(tool.id, resolve(tool.id, []));
+    for (const id of cyclic)
+        depths.set(id, 0);
+    return depths;
+}