@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/chat/turn-process.js

@@ -0,0 +1,346 @@
+/**
+ * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
+ */
+import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
+import { semanticActivityForTool, } from "./semantic-activity.js";
+function emptyGroup(key) {
+    return {
+        key,
+        assistants: [],
+        tools: [],
+        processItems: [],
+        live: false,
+    };
+}
+/**
+ * Restore chat bubbles + tool cards from durable session messages.
+ * Tool rows often appear before the final assistant `message_end` message;
+ * synthetic turn ids bridge that gap for later grouping.
+ */
+export function hydrateSessionThread(raw) {
+    const messages = [];
+    const toolCalls = [];
+    let turnId;
+    let pendingTools = [];
+    const flushPendingToAssistant = (assistantId) => {
+        for (const tool of pendingTools) {
+            if (!tool.assistantMessageId)
+                tool.assistantMessageId = assistantId;
+            if (!tool.turnId)
+                tool.turnId = turnId;
+        }
+        pendingTools = [];
+    };
+    for (const item of raw) {
+        const createdAt = Date.parse(item.at) || Date.now();
+        if (item.role === "user") {
+            turnId = `restored-${item.id}`;
+            pendingTools = [];
+            messages.push({
+                id: item.id,
+                role: "user",
+                text: item.text,
+                createdAt,
+            });
+            continue;
+        }
+        if (item.role === "assistant") {
+            if (!turnId)
+                turnId = `restored-${item.id}`;
+            const content = parseAssistantContent(item.content);
+            messages.push({
+                id: item.id,
+                role: "assistant",
+                text: item.text,
+                createdAt,
+                ...(content && content.length > 0 ? { content } : {}),
+            });
+            flushPendingToAssistant(item.id);
+            continue;
+        }
+        if (item.role === "tool") {
+            if (!turnId)
+                turnId = `restored-tool-${item.id}`;
+            const entry = {
+                id: item.toolCallId || item.id,
+                toolName: item.toolName || "tool",
+                status: item.isError === true ? "error" : "ok",
+                resultText: item.text,
+                result: item.text,
+                createdAt,
+                finishedAt: createdAt,
+                turnId,
+                ...(item.operationId ? { operationId: item.operationId } : {}),
+            };
+            toolCalls.push(entry);
+            pendingTools.push(entry);
+        }
+    }
+    return { messages, toolCalls };
+}
+/** Stable tool order: server eventSeq first, createdAt fallback, id tiebreak. */
+function sortToolsStable(tools) {
+    return [...tools].sort((a, b) => {
+        if (a.eventSeq !== undefined &&
+            b.eventSeq !== undefined &&
+            a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        return a.id < b.id ? -1 : 1;
+    });
+}
+/**
+ * Flush buffered consecutive tools into process items (pi-web aligned:
+ * strict sequential flow, no synthetic grouping). Semantic operator tools
+ * stay as individual activity events; plain tools each render as their own
+ * card in stable server order (eventSeq first, createdAt fallback).
+ * Thinking/text/activity boundaries break the buffer upstream.
+ */
+function flushToolBuffer(processItems, buffer) {
+    if (buffer.length === 0)
+        return;
+    const sorted = sortToolsStable(buffer);
+    for (const tool of sorted) {
+        const activity = semanticActivityForTool(tool);
+        if (activity) {
+            processItems.push({ kind: "activity", activity });
+        }
+        else {
+            processItems.push({ kind: "tool", tool });
+        }
+    }
+}
+function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
+    let buffer = [];
+    for (const block of blocks) {
+        if (block.type === "thinking") {
+            flushToolBuffer(processItems, buffer);
+            buffer = [];
+            processItems.push({ kind: "thinking", thinking: block.thinking });
+            continue;
+        }
+        if (block.type === "text") {
+            flushToolBuffer(processItems, buffer);
+            buffer = [];
+            if (block.text.trim()) {
+                processItems.push({ kind: "text", text: block.text });
+            }
+            continue;
+        }
+        const tool = group.tools.find((entry) => entry.id === block.toolCallId);
+        if (tool && !usedToolIds.has(tool.id)) {
+            buffer.push(tool);
+            usedToolIds.add(tool.id);
+        }
+    }
+    flushToolBuffer(processItems, buffer);
+}
+/**
+ * Insert tools attributed to this assistant stage but without a matching
+ * content toolCall block (live SSE tool_call frames often arrive before the
+ * assistant content does). They follow the stage's thinking/text instead of
+ * sinking to the end of the whole turn.
+ */
+function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds) {
+    const unmatched = group.tools.filter((tool) => !usedToolIds.has(tool.id) && tool.assistantMessageId === assistant.id);
+    if (unmatched.length === 0)
+        return;
+    for (const tool of unmatched)
+        usedToolIds.add(tool.id);
+    flushToolBuffer(processItems, unmatched);
+}
+function fillProcessDetails(group) {
+    const usedToolIds = new Set();
+    const processItems = [];
+    const prior = group.assistants.slice(0, -1);
+    const finalAssistant = group.assistants.at(-1);
+    for (const assistant of prior) {
+        emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
+        appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+    }
+    const blocks = finalAssistant?.content ?? [];
+    const split = splitFinalAssistantBlocks(blocks, { isStreaming: group.live });
+    emitProcessBlocks(split.processBlocks, group, processItems, usedToolIds);
+    if (finalAssistant) {
+        appendAssistantUnmatchedTools(group, finalAssistant, processItems, usedToolIds);
+    }
+    // Bounded fallback for legacy restored rows with no assistant attribution:
+    // keep them at this turn's end in stable server order instead of randomly
+    // interleaving them into earlier stages.
+    const orphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
+    if (orphans.length > 0)
+        flushToolBuffer(processItems, orphans);
+    group.processItems = processItems;
+    if (!finalAssistant)
+        return;
+    if (blocks.length === 0) {
+        group.answer = finalAssistant;
+        return;
+    }
+    const answerText = joinAssistantText(split.answerBlocks);
+    group.answer = {
+        ...finalAssistant,
+        text: answerText,
+        content: split.answerBlocks,
+    };
+}
+/**
+ * Build user → process → answer groups for the message timeline.
+ */
+export function buildTurnProcessGroups(input) {
+    const visible = input.messages.filter((m) => m.role === "user" || m.role === "assistant");
+    const groups = [];
+    let current = null;
+    const startGroup = (key) => {
+        const group = emptyGroup(key);
+        groups.push(group);
+        return group;
+    };
+    for (const message of visible) {
+        if (message.role === "user") {
+            current = startGroup(`user-${message.id}`);
+            current.user = message;
+            continue;
+        }
+        if (message.kind === "compaction") {
+            // Compaction is a standalone timeline event. Starting a fresh group
+            // prevents it from replacing the previous turn's assistant answer.
+            current = startGroup(`compaction-${message.id}`);
+            current.assistants.push(message);
+            current = null;
+            continue;
+        }
+        if (!current)
+            current = startGroup(`assistant-${message.id}`);
+        current.assistants.push(message);
+    }
+    const assigned = new Set();
+    const assistantToGroup = new Map();
+    for (const group of groups) {
+        for (const assistant of group.assistants) {
+            assistantToGroup.set(assistant.id, group);
+        }
+    }
+    for (const tool of input.toolCalls) {
+        if (tool.assistantMessageId) {
+            const group = assistantToGroup.get(tool.assistantMessageId);
+            if (group) {
+                group.tools.push(tool);
+                assigned.add(tool.id);
+            }
+        }
+    }
+    for (const tool of input.toolCalls) {
+        if (assigned.has(tool.id))
+            continue;
+        if (tool.turnId) {
+            const byTurn = groups.find((group) => group.tools.some((t) => t.turnId === tool.turnId) ||
+                group.key === `turn-${tool.turnId}` ||
+                (group.user && `restored-${group.user.id}` === tool.turnId));
+            if (byTurn) {
+                byTurn.tools.push(tool);
+                assigned.add(tool.id);
+                continue;
+            }
+            // Match restored turn id `restored-<userOrAssistantId>`
+            const restored = groups.find((group) => tool.turnId === `restored-${group.user?.id}` ||
+                group.assistants.some((a) => tool.turnId === `restored-${a.id}`));
+            if (restored) {
+                restored.tools.push(tool);
+                assigned.add(tool.id);
+            }
+        }
+    }
+    for (const tool of input.toolCalls) {
+        if (assigned.has(tool.id))
+            continue;
+        const windowGroup = groups.find((group, index) => {
+            const start = group.user?.createdAt ?? group.assistants[0]?.createdAt ?? 0;
+            const next = groups[index + 1];
+            const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
+            return tool.createdAt >= start && tool.createdAt < end;
+        });
+        // Time window only. Never dump unmatched tools onto the latest group:
+        // that is how a previous turn's bash cards jump under a new prompt.
+        if (windowGroup) {
+            windowGroup.tools.push(tool);
+            assigned.add(tool.id);
+        }
+    }
+    for (const group of groups) {
+        group.tools.sort((a, b) => {
+            if (a.eventSeq !== undefined && b.eventSeq !== undefined) {
+                return a.eventSeq - b.eventSeq;
+            }
+            return a.createdAt - b.createdAt;
+        });
+        group.live =
+            input.streaming &&
+                input.activeAssistantId !== null &&
+                group.assistants.some((a) => a.id === input.activeAssistantId);
+        fillProcessDetails(group);
+    }
+    return groups;
+}
+/** Keep the most recent complete turns. Slice groups, never raw messages. */
+export function selectRecentTurnGroups(groups, limit) {
+    if (limit <= 0)
+        return [];
+    if (groups.length <= limit)
+        return [...groups];
+    return groups.slice(-limit);
+}
+export function processGroupSummary(tools, options) {
+    const count = tools.length;
+    const thinkingCount = options?.thinkingCount ?? 0;
+    const textCount = options?.textCount ?? 0;
+    const activityCount = options?.activityCount ?? 0;
+    const stepCount = thinkingCount + textCount + activityCount + count;
+    const errorCount = tools.filter((t) => t.status === "error").length +
+        (options?.activityErrorCount ?? 0);
+    const runningCount = tools.filter((t) => t.status === "running").length +
+        (options?.activityRunningCount ?? 0);
+    const parts = [`处理详情 · ${stepCount} 步`];
+    if (count > 0)
+        parts.push(`${count} 工具`);
+    if (activityCount > 0)
+        parts.push(`${activityCount} 进展`);
+    if (errorCount > 0)
+        parts.push(`${errorCount} 出错`);
+    else if (runningCount > 0)
+        parts.push("运行中");
+    return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
+}
+/** Summary over rendered process items. */
+export function summarizeProcessItems(items) {
+    const tools = [];
+    let thinkingCount = 0;
+    let textCount = 0;
+    let activityCount = 0;
+    let activityErrorCount = 0;
+    let activityRunningCount = 0;
+    for (const item of items) {
+        if (item.kind === "thinking")
+            thinkingCount += 1;
+        else if (item.kind === "text")
+            textCount += 1;
+        else if (item.kind === "activity") {
+            activityCount += 1;
+            if (item.activity.kind === "error")
+                activityErrorCount += 1;
+            else if (item.activity.kind === "progress")
+                activityRunningCount += 1;
+        }
+        else
+            tools.push(item.tool);
+    }
+    return processGroupSummary(tools, {
+        thinkingCount,
+        textCount,
+        activityCount,
+        activityErrorCount,
+        activityRunningCount,
+    });
+}

package/dist/worker/console/chat/usage.js

@@ -0,0 +1,165 @@
+function record(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function numberAt(source, keys) {
+    for (const key of keys) {
+        if (typeof source[key] === "number" && Number.isFinite(source[key])) {
+            return Math.max(0, source[key]);
+        }
+    }
+    return undefined;
+}
+function costAt(source) {
+    const direct = numberAt(source, ["cost"]);
+    if (direct !== undefined)
+        return direct;
+    const nested = record(source.cost);
+    if (!nested)
+        return undefined;
+    return numberAt(nested, ["total", "amount"]);
+}
+/**
+ * Extract usage from Pi SDK / OpenAI-shaped events.
+ * Pi assistant usage uses `{ input, output, cacheRead, cacheWrite, totalTokens, cost }`.
+ */
+export function extractUsageSample(value) {
+    const event = record(value);
+    if (!event)
+        return undefined;
+    const message = record(event.message);
+    const source = record(event.usage) ??
+        record(message?.usage) ??
+        record(event.tokenUsage);
+    if (!source)
+        return undefined;
+    const inputTokens = numberAt(source, [
+        "input",
+        "input_tokens",
+        "inputTokens",
+        "prompt_tokens",
+        "promptTokens",
+    ]);
+    const outputTokens = numberAt(source, [
+        "output",
+        "output_tokens",
+        "outputTokens",
+        "completion_tokens",
+        "completionTokens",
+    ]);
+    const cacheReadTokens = numberAt(source, [
+        "cacheRead",
+        "cache_read",
+        "cache_read_input_tokens",
+        "cacheReadTokens",
+    ]);
+    const cacheWriteTokens = numberAt(source, [
+        "cacheWrite",
+        "cache_write",
+        "cache_creation_input_tokens",
+        "cacheWriteTokens",
+    ]);
+    const partsSum = (inputTokens ?? 0) +
+        (outputTokens ?? 0) +
+        (cacheReadTokens ?? 0) +
+        (cacheWriteTokens ?? 0);
+    const hasParts = inputTokens !== undefined ||
+        outputTokens !== undefined ||
+        cacheReadTokens !== undefined ||
+        cacheWriteTokens !== undefined;
+    const totalTokens = numberAt(source, ["total_tokens", "totalTokens"]) ??
+        (hasParts ? partsSum : undefined);
+    const cost = costAt(source);
+    if (inputTokens === undefined &&
+        outputTokens === undefined &&
+        cacheReadTokens === undefined &&
+        cacheWriteTokens === undefined &&
+        totalTokens === undefined &&
+        cost === undefined) {
+        return undefined;
+    }
+    const responseKey = [
+        event.responseId,
+        message?.id,
+        source.responseId,
+    ].find((item) => typeof item === "string");
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(cacheReadTokens !== undefined ? { cacheReadTokens } : {}),
+        ...(cacheWriteTokens !== undefined ? { cacheWriteTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+        ...(responseKey ? { responseKey } : {}),
+    };
+}
+export function aggregateUsage(samples) {
+    const keyed = new Map();
+    const anonymous = [];
+    for (const sample of samples) {
+        if (sample.responseKey)
+            keyed.set(sample.responseKey, sample);
+        else
+            anonymous.push(sample);
+    }
+    const selected = [...keyed.values(), ...anonymous];
+    return selected.reduce((sum, sample) => {
+        const input = sample.inputTokens ?? 0;
+        const output = sample.outputTokens ?? 0;
+        const cacheRead = sample.cacheReadTokens ?? 0;
+        const cacheWrite = sample.cacheWriteTokens ?? 0;
+        const total = sample.totalTokens ?? input + output + cacheRead + cacheWrite;
+        return {
+            inputTokens: sum.inputTokens + input,
+            outputTokens: sum.outputTokens + output,
+            cacheReadTokens: sum.cacheReadTokens + cacheRead,
+            cacheWriteTokens: sum.cacheWriteTokens + cacheWrite,
+            totalTokens: sum.totalTokens + total,
+            cost: sample.cost === undefined
+                ? sum.cost
+                : (sum.cost ?? 0) + sample.cost,
+            estimated: Boolean(sum.estimated || sample.estimated),
+        };
+    }, {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+    });
+}
+/** Compact token count aligned with pi-web SessionInfoBar / ChatInput. */
+export function formatTokenCount(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(1)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(1)}k`;
+    return tokens.toLocaleString();
+}
+/**
+ * Status-line usage text aligned with pi-web SessionInfoBar chips:
+ * `12.3k in · 1.2k out · 8.0k cache R · $0.01`
+ */
+export function formatUsageStatusLine(usage) {
+    const parts = [];
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    const cost = usage.cost ?? 0;
+    if (input > 0)
+        parts.push(`${formatTokenCount(input)} in`);
+    if (output > 0)
+        parts.push(`${formatTokenCount(output)} out`);
+    if (cacheRead > 0)
+        parts.push(`${formatTokenCount(cacheRead)} cache R`);
+    if (cacheWrite > 0)
+        parts.push(`${formatTokenCount(cacheWrite)} cache W`);
+    if (cost > 0) {
+        parts.push(cost >= 0.01 ? `$${cost.toFixed(2)}` : "<$0.01");
+    }
+    if (parts.length === 0) {
+        const total = usage.totalTokens ?? 0;
+        return total > 0 ? `${formatTokenCount(total)} tokens` : "—";
+    }
+    return parts.join(" · ");
+}

package/dist/worker/console/chat/workspace-landing.js

@@ -0,0 +1,103 @@
+export const ACTIVE_CHAT_SESSION_STORAGE_KEY = "loop-console.operator-chat.active-session.v1";
+export const DEFAULT_LANDING_STORAGE_KEY = "loop-console.operator-chat.default-landing.v1";
+function configuredLanding(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "chat")
+        return "chat";
+    if (normalized === "tasks")
+        return "tasks";
+    return undefined;
+}
+function configuredWorkspace(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "chat" ||
+        normalized === "tasks" ||
+        normalized === "recovery" ||
+        normalized === "night" ||
+        normalized === "models" ||
+        normalized === "settings") {
+        return normalized;
+    }
+    return undefined;
+}
+function readWorkspaceParams(query) {
+    const read = (key) => query.get(key)?.trim() || undefined;
+    return {
+        ...(read("taskId") ? { taskId: read("taskId") } : {}),
+        ...(read("dagRunId") ? { dagRunId: read("dagRunId") } : {}),
+        ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
+        ...(read("featureId") ? { featureId: read("featureId") } : {}),
+        ...(read("intent") ? { intent: read("intent") } : {}),
+    };
+}
+/** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */
+export function parseConsoleHashRoute(hashValue) {
+    const raw = String(hashValue ?? "").replace(/^#/, "");
+    if (!raw)
+        return null;
+    const qIndex = raw.indexOf("?");
+    const pathPart = qIndex >= 0 ? raw.slice(0, qIndex) : raw;
+    const queryPart = qIndex >= 0 ? raw.slice(qIndex + 1) : "";
+    const path = (pathPart || "/").split("?")[0] || "/";
+    if (path === "/" || path === "")
+        return null;
+    const segment = path.replace(/^\//, "").split("/")[0];
+    const workspace = configuredWorkspace(segment);
+    if (!workspace)
+        return null;
+    return { workspace, ...readWorkspaceParams(new URLSearchParams(queryPart)) };
+}
+function parseLegacyWorkspaceHref(location) {
+    const query = new URLSearchParams(location.search);
+    const hash = location.hash.startsWith("#")
+        ? location.hash.slice(1)
+        : location.hash;
+    const hashQuery = new URLSearchParams(hash);
+    const workspace = configuredWorkspace(query.get("workspace") ??
+        query.get("landing") ??
+        hashQuery.get("workspace"));
+    if (!workspace)
+        return null;
+    return { workspace, ...readWorkspaceParams(query) };
+}
+function workspaceFromLocation(location) {
+    if (!location)
+        return undefined;
+    const hashRoute = parseConsoleHashRoute(location.hash);
+    if (hashRoute)
+        return hashRoute.workspace;
+    const query = new URLSearchParams(location.search);
+    const queryValue = configuredLanding(query.get("landing") ?? query.get("workspace"));
+    if (queryValue)
+        return queryValue;
+    const hash = location.hash.startsWith("#")
+        ? location.hash.slice(1)
+        : location.hash;
+    return configuredLanding(new URLSearchParams(hash).get("workspace"));
+}
+export function resolveDefaultLanding(input) {
+    return (workspaceFromLocation(input.location) ??
+        configuredLanding(input.storage?.getItem(DEFAULT_LANDING_STORAGE_KEY)) ??
+        configuredLanding(input.env) ??
+        "chat");
+}
+/** Hash path segment for Console virtual routing (no leading `#`). */
+export function buildConsoleHashPath(workspace, params = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value?.trim())
+            query.set(key, value.trim());
+    }
+    const qs = query.toString();
+    const base = `/${workspace}`;
+    return qs ? `${base}?${qs}` : base;
+}
+export function buildWorkspaceHref(workspace, params = {}) {
+    return `#${buildConsoleHashPath(workspace, params)}`;
+}
+export function parseConsoleRoute(location) {
+    return (parseConsoleHashRoute(location.hash) ?? parseLegacyWorkspaceHref(location));
+}
+export function parseWorkspaceHref(location) {
+    return parseConsoleRoute(location);
+}