@tea-agent/loop-agent 0.37.0 → 0.37.1-beta.0

package/dist/worker/console/chat/assistant-content.js

@@ -1,121 +0,0 @@
-/**
- * Assistant content-block helpers shared by Pi event mapping and Operator Chat UI.
- * Mirrors pi-web `lib/message-display.ts` (process vs answer split) without deferred fetch.
- */
-function asRecord(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    return value;
-}
-function readString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-/** Parse a persisted/SSE content array; unknown shapes are dropped. */
-export function parseAssistantContent(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const blocks = [];
-    for (const item of value) {
-        const rec = asRecord(item);
-        if (!rec)
-            continue;
-        const type = readString(rec.type) ?? "";
-        if (type === "thinking" || type === "reasoning") {
-            const thinking = readString(rec.thinking) ?? readString(rec.text) ?? "";
-            blocks.push({ type: "thinking", thinking });
-            continue;
-        }
-        if (type === "toolCall" ||
-            type === "tool_call" ||
-            type === "toolUse" ||
-            type === "tool_use") {
-            const toolCallId = readString(rec.toolCallId) ?? readString(rec.id) ?? "";
-            if (!toolCallId)
-                continue;
-            const toolName = readString(rec.toolName) ?? readString(rec.name);
-            blocks.push({
-                type: "toolCall",
-                toolCallId,
-                ...(toolName ? { toolName } : {}),
-            });
-            continue;
-        }
-        if (type === "text" || type === "output_text" || type === "") {
-            const text = readString(rec.text);
-            if (text !== undefined)
-                blocks.push({ type: "text", text });
-        }
-    }
-    return blocks;
-}
-/**
- * Extract ordered assistant content blocks from a Pi SDK message object.
- * Thinking/reasoning blocks keep their own type so they never leak into answer text.
- */
-export function extractAssistantContentBlocks(message) {
-    const rec = asRecord(message);
-    if (!rec)
-        return [];
-    const contents = Array.isArray(rec.content) ? rec.content : [];
-    const parts = Array.isArray(rec.parts) ? rec.parts : [];
-    const fromArrays = parseAssistantContent([...contents, ...parts]) ?? [];
-    if (fromArrays.length > 0)
-        return fromArrays;
-    const top = readString(rec.text);
-    return top ? [{ type: "text", text: top }] : [];
-}
-/**
- * Pi emits message_end for user / toolResult / custom too. Only assistant
- * payloads belong in the Operator Chat assistant bubble (pi-web same split).
- */
-export function isAssistantSdkMessage(message) {
-    const rec = asRecord(message);
-    if (!rec)
-        return false;
-    const role = readString(rec.role);
-    return role === undefined || role === "assistant";
-}
-/**
- * Latest assistant answer text (text blocks only). Thinking is excluded.
- * Preserves the historical `{ text }` / `{ parts: [{ text }] }` fallbacks.
- */
-export function extractAssistantText(message) {
-    return extractAssistantContentBlocks(message)
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("");
-}
-export function isEmptyThinkingBlock(block, options = {}) {
-    return (block.type === "thinking" &&
-        !options.isStreaming &&
-        block.thinking.trim() === "");
-}
-export function getDisplayableAssistantBlocks(blocks, options = {}) {
-    return blocks.filter((block) => !isEmptyThinkingBlock(block, options));
-}
-function isFinalAnswerBlock(block) {
-    return block.type === "text";
-}
-export function splitFinalAssistantBlocks(blocks, options = {}) {
-    const displayable = getDisplayableAssistantBlocks(blocks, options);
-    let lastProcessIndex = -1;
-    for (let i = displayable.length - 1; i >= 0; i--) {
-        if (!isFinalAnswerBlock(displayable[i])) {
-            lastProcessIndex = i;
-            break;
-        }
-    }
-    if (lastProcessIndex === -1) {
-        return { answerBlocks: displayable, processBlocks: [] };
-    }
-    return {
-        answerBlocks: displayable.slice(lastProcessIndex + 1),
-        processBlocks: displayable.slice(0, lastProcessIndex + 1),
-    };
-}
-export function joinAssistantText(blocks) {
-    return blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("");
-}

package/dist/worker/console/chat/semantic-activity.js

@@ -1,477 +0,0 @@
-const TECHNICAL_ONLY_TOOLS = new Set([
-    "operatorCapabilities",
-    "operationList",
-    "operationGet",
-    "operationEventSummary",
-    "statsContext",
-    "sourceInstructions",
-    "spineCheck",
-    "inspect",
-    "observeLink",
-]);
-export function semanticToolPresentation(toolName) {
-    if (TECHNICAL_ONLY_TOOLS.has(toolName))
-        return "technical-only";
-    if (toolName === "doctor")
-        return "inline-detail";
-    return "activity-detail";
-}
-const OPERATION_TITLES = {
-    newTask: "创建任务",
-    importPrd: "任务需求",
-    contractShow: "任务边界",
-    contractApply: "更新任务契约",
-    contractDiff: "任务契约差异",
-    contractDraftSave: "任务契约草稿",
-    contractValidate: "检查任务契约",
-    taskAdvance: "推进任务准备",
-    dagRunTask: "执行流程",
-    dagValidate: "校验执行流程",
-    prepareDagConfirmation: "执行确认",
-    confirmDagConfirmation: "确认执行边界",
-    prepareDagExecution: "执行边界",
-    runDag: "任务执行",
-    operationWait: "执行监督",
-    operationGet: "任务活动详情",
-    operationList: "会话活动",
-    operationEventSummary: "执行进展摘要",
-    dagStatus: "执行状态",
-    dagDoctor: "执行诊断",
-    dagReport: "执行结果",
-    dagRerunPlan: "恢复评估",
-    dagInterruptEligibility: "中止资格",
-    standaloneTaskRerun: "恢复执行",
-    workerTaskRetry: "重试任务",
-    promoteRun: "任务推进",
-    status: "任务状态",
-};
-const TOOL_SEMANTICS = {
-    newTask: {
-        running: "正在创建任务",
-        success: "任务已经创建",
-        error: "创建任务时遇到问题",
-    },
-    importPrd: {
-        running: "正在整理并导入任务需求",
-        success: "任务需求已经导入",
-        error: "导入任务需求时遇到问题",
-    },
-    contractShow: {
-        running: "正在读取任务目标和执行边界",
-        success: "任务目标与执行边界已经读取",
-        error: "读取任务边界时遇到问题",
-    },
-    taskAdvance: {
-        running: "正在推进任务契约并准备执行流程",
-        success: "任务已经推进到下一安全阶段",
-        error: "任务推进被契约或执行边界阻塞",
-    },
-    dagRunTask: {
-        running: "正在生成并校验执行流程",
-        success: "执行流程已经准备好",
-        error: "准备执行流程时遇到问题",
-    },
-    prepareDagExecution: {
-        running: "正在确认任务可以安全执行",
-        success: "执行边界已经确认",
-        error: "执行边界尚未通过确认",
-    },
-    runDag: {
-        running: "正在启动任务执行",
-        success: "任务执行已经启动",
-        error: "启动任务执行时遇到问题",
-    },
-    dagReport: {
-        running: "正在读取本次执行结果",
-        success: "本次执行结果已经读取",
-        error: "读取执行结果时遇到问题",
-    },
-    dagRerunPlan: {
-        running: "正在评估能否从失败位置继续",
-        success: "恢复条件评估已经完成",
-        error: "暂时无法确定安全的恢复方式",
-    },
-    dagInterruptEligibility: {
-        running: "正在检查能否协作中止此运行",
-        success: "中止资格已经确认",
-        error: "当前运行不能协作中止",
-    },
-    standaloneTaskRerun: {
-        running: "正在从失败位置恢复执行",
-        success: "已经从失败位置继续执行",
-        error: "从失败位置恢复执行时遇到问题",
-    },
-    promoteRun: {
-        running: "正在推进任务状态",
-        success: "任务状态已经更新",
-        error: "推进任务状态时遇到问题",
-    },
-    status: {
-        running: "正在读取任务状态",
-        success: "任务状态已经更新",
-        error: "读取任务状态时遇到问题",
-    },
-    contractApply: {
-        running: "正在应用任务契约变更",
-        success: "任务契约已经更新",
-        error: "应用任务契约变更时遇到问题",
-    },
-    contractDiff: {
-        running: "正在比较任务契约版本",
-        success: "任务契约差异已经读取",
-        error: "比较任务契约时遇到问题",
-    },
-    contractDraftSave: {
-        running: "正在保存任务契约草稿",
-        success: "任务契约草稿已经保存",
-        error: "保存任务契约草稿时遇到问题",
-    },
-    contractValidate: {
-        running: "正在检查任务契约",
-        success: "任务契约检查已经完成",
-        error: "任务契约检查没有通过",
-    },
-    dagValidate: {
-        running: "正在校验执行流程",
-        success: "执行流程校验已经通过",
-        error: "执行流程校验没有通过",
-    },
-    prepareDagConfirmation: {
-        running: "正在准备执行确认",
-        success: "执行确认已经准备好",
-        error: "准备执行确认时遇到问题",
-    },
-    confirmDagConfirmation: {
-        running: "正在确认执行边界",
-        success: "执行边界已经确认",
-        error: "执行边界尚未通过确认",
-    },
-    operationGet: {
-        running: "正在读取任务活动详情",
-        success: "任务活动详情已经读取",
-        error: "读取任务活动详情时遇到问题",
-    },
-    operationList: {
-        running: "正在读取本次对话的活动",
-        success: "本次对话的活动已经读取",
-        error: "读取对话活动时遇到问题",
-    },
-    operationEventSummary: {
-        running: "正在汇总执行进展",
-        success: "执行进展已经汇总",
-        error: "汇总执行进展时遇到问题",
-    },
-    dagStatus: {
-        running: "正在读取执行状态",
-        success: "执行状态已经更新",
-        error: "读取执行状态时遇到问题",
-    },
-    dagDoctor: {
-        running: "正在诊断本次任务执行",
-        success: "任务执行诊断已经完成",
-        error: "诊断任务执行时遇到问题",
-    },
-    workerTaskRetry: {
-        running: "正在重试失败的任务",
-        success: "失败任务已经重新开始",
-        error: "重试失败任务时遇到问题",
-    },
-    doctor: {
-        running: "正在检查运行环境",
-        success: "运行环境检查已经完成",
-        error: "运行环境检查发现问题",
-    },
-    inspect: {
-        running: "正在读取详细运行信息",
-        success: "详细运行信息已经读取",
-        error: "读取详细运行信息时遇到问题",
-    },
-    observeLink: {
-        running: "正在准备运行看板入口",
-        success: "运行看板入口已经准备好",
-        error: "准备运行看板入口时遇到问题",
-    },
-    operatorCapabilities: {
-        running: "正在读取可用操作能力",
-        success: "可用操作能力已经读取",
-        error: "读取可用操作能力时遇到问题",
-    },
-    sourceInstructions: {
-        running: "正在读取任务来源说明",
-        success: "任务来源说明已经读取",
-        error: "读取任务来源说明时遇到问题",
-    },
-    spineCheck: {
-        running: "正在检查计划执行步骤",
-        success: "计划执行步骤检查已经完成",
-        error: "计划执行步骤检查发现问题",
-    },
-    statsContext: {
-        running: "正在统计上下文使用情况",
-        success: "上下文使用情况已经统计完成",
-        error: "统计上下文使用情况时遇到问题",
-    },
-};
-const NODE_LABELS = [
-    {
-        pattern: /(?:^|-)contract(?:-pi)?$/i,
-        running: "正在核对任务目标和执行边界",
-        finished: "任务目标与执行边界已确认",
-        error: "任务边界存在冲突，需要先处理",
-    },
-    {
-        pattern: /scout-src/i,
-        running: "正在梳理与任务相关的代码",
-        finished: "相关代码范围已梳理",
-        error: "梳理相关代码时遇到问题",
-    },
-    {
-        pattern: /scout-tests/i,
-        running: "正在检查现有测试和验证方式",
-        finished: "现有测试与验证方式已确认",
-        error: "检查现有测试时遇到问题",
-    },
-    {
-        pattern: /plan/i,
-        running: "正在整理具体实施步骤",
-        finished: "实施步骤已经准备好",
-        error: "实施方案还需要进一步完善",
-    },
-    {
-        pattern: /implement|writer/i,
-        running: "正在修改并保存相关文件",
-        finished: "文件修改已经完成",
-        error: "修改文件时遇到问题",
-    },
-    {
-        pattern: /verify|reverify/i,
-        running: "正在验证本次修改",
-        finished: "本次修改已通过验证",
-        error: "验证没有通过，正在检查原因",
-    },
-    {
-        pattern: /review/i,
-        running: "正在检查改动是否完整",
-        finished: "改动完整性检查已通过",
-        error: "发现需要补充或修正的内容",
-    },
-    {
-        pattern: /closeout/i,
-        running: "正在整理交付结果",
-        finished: "任务已经完成并形成交付记录",
-        error: "交付结果尚未整理完整",
-    },
-];
-function asRecord(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    return value;
-}
-function parseJsonRecord(value) {
-    if (value && typeof value === "object")
-        return value;
-    if (typeof value !== "string")
-        return undefined;
-    try {
-        return asRecord(JSON.parse(value));
-    }
-    catch {
-        return undefined;
-    }
-}
-function operationIdFromArgs(args) {
-    const record = parseJsonRecord(args);
-    const operationId = record?.operationId;
-    return typeof operationId === "string" && operationId ? operationId : undefined;
-}
-function maxWaitSeconds(args) {
-    const record = parseJsonRecord(args);
-    const raw = record?.maxWaitMs;
-    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
-        return undefined;
-    return Math.max(1, Math.round(raw / 1000));
-}
-function activityRefForTool(tool) {
-    // Plan A (2026-08-16): server backfills operationId on the persisted tool
-    // entry (and live tool_result frames carry it in the result payload), so
-    // prefer the authoritative link before parsing args/result fallbacks.
-    const operationId = tool.operationId ??
-        operationIdFromArgs(tool.args) ??
-        operationIdFromArgs(tool.result) ??
-        operationIdFromArgs(tool.resultText);
-    return operationId ? `operation:${operationId}` : `tool:${tool.id}`;
-}
-function semanticKindForStatus(status) {
-    if (status === "running")
-        return "progress";
-    if (status === "error")
-        return "error";
-    return "success";
-}
-function resultRecord(tool) {
-    return parseJsonRecord(tool.resultText ?? tool.result);
-}
-function eventMessages(record) {
-    if (!Array.isArray(record.events))
-        return [];
-    return record.events.flatMap((value) => {
-        const event = asRecord(value);
-        if (!event)
-            return [];
-        const message = event.messagePreview ?? event.message;
-        return typeof message === "string" ? [message] : [];
-    });
-}
-function nodeActivityFromMessages(messages, id, activityRef) {
-    const facts = [];
-    for (const message of messages) {
-        for (const match of message.matchAll(/node-(started|finished)[^\n]*?node=([^\s,]+)/gi)) {
-            const lifecycle = match[1]?.toLowerCase();
-            const node = match[2] ?? "";
-            const statusMatch = message.match(/status=([^\s,]+)/i)?.[1]?.toUpperCase();
-            let status = "finished";
-            if (statusMatch === "ERROR" || statusMatch === "FAILED")
-                status = "error";
-            else if (lifecycle === "started")
-                status = "running";
-            facts.push({ node, status });
-        }
-    }
-    const latest = facts.at(-1);
-    if (!latest)
-        return undefined;
-    const scoutSrcFinished = facts.some((fact) => /scout-src/i.test(fact.node) && fact.status === "finished");
-    const scoutTestsFinished = facts.some((fact) => /scout-tests/i.test(fact.node) && fact.status === "finished");
-    if (scoutSrcFinished && scoutTestsFinished) {
-        return {
-            id,
-            kind: "success",
-            title: "代码与测试的影响范围已确认",
-            activityRef,
-        };
-    }
-    const label = NODE_LABELS.find((candidate) => candidate.pattern.test(latest.node));
-    if (!label) {
-        return { id, kind: "success", title: "执行状态已经更新", activityRef };
-    }
-    if (latest.status === "running") {
-        return { id, kind: "progress", title: label.running, activityRef };
-    }
-    if (latest.status === "error") {
-        return { id, kind: "error", title: label.error, activityRef };
-    }
-    return { id, kind: "success", title: label.finished, activityRef };
-}
-function operationWaitActivity(tool) {
-    const activityRef = activityRefForTool(tool);
-    const id = `activity:${tool.id}`;
-    const seconds = maxWaitSeconds(tool.args);
-    if (tool.status === "running") {
-        return {
-            id,
-            kind: "progress",
-            title: seconds
-                ? `正在等待新的执行进展，最长等待时间 ${seconds} 秒`
-                : "正在等待新的执行进展",
-            activityRef,
-        };
-    }
-    if (tool.status === "error") {
-        return {
-            id,
-            kind: "error",
-            title: "等待执行进展时遇到问题",
-            activityRef,
-        };
-    }
-    let rawResult = "";
-    if (typeof tool.resultText === "string")
-        rawResult = tool.resultText;
-    else if (typeof tool.result === "string")
-        rawResult = tool.result;
-    const record = resultRecord(tool);
-    const nodeActivity = nodeActivityFromMessages([rawResult, ...(record ? eventMessages(record) : [])], id, activityRef);
-    if (nodeActivity)
-        return nodeActivity;
-    if (record) {
-        if (record.timedOut === true || record.changed === false) {
-            return {
-                id,
-                kind: "warning",
-                title: "等待期间没有新的执行进展",
-                activityRef,
-            };
-        }
-        if (record.changed === true) {
-            return {
-                id,
-                kind: "success",
-                title: "已经收到新的执行进展",
-                activityRef,
-            };
-        }
-    }
-    return {
-        id,
-        kind: "success",
-        title: "执行状态已经更新",
-        activityRef,
-    };
-}
-/**
- * Return a deterministic, human-written semantic event for Operator tools.
- * Ordinary read/bash/edit tools intentionally return undefined and retain the
- * existing technical ToolCard representation.
- */
-export function semanticActivityForTool(tool) {
-    const presentation = semanticToolPresentation(tool.toolName);
-    if (presentation === "technical-only" || presentation === "inline-detail") {
-        return undefined;
-    }
-    if (tool.toolName === "operationWait")
-        return operationWaitActivity(tool);
-    const semantic = TOOL_SEMANTICS[tool.toolName];
-    if (!semantic)
-        return undefined;
-    let title = semantic.success;
-    if (tool.status === "running")
-        title = semantic.running;
-    else if (tool.status === "error")
-        title = semantic.error;
-    return {
-        id: `activity:${tool.id}`,
-        kind: semanticKindForStatus(tool.status),
-        title,
-        activityRef: activityRefForTool(tool),
-    };
-}
-export function semanticOperationTitle(action) {
-    return OPERATION_TITLES[action] ?? "任务活动";
-}
-export function semanticOperationState(state) {
-    switch (state) {
-        case "starting":
-            return { label: "正在启动", kind: "progress" };
-        case "running":
-            return { label: "运行中", kind: "progress" };
-        case "succeeded":
-        case "finished":
-        case "FINISHED":
-        case "pass":
-            return { label: "已完成", kind: "success" };
-        case "failed":
-        case "partial_failed":
-        case "ERROR":
-        case "FAILED":
-        case "timed-out":
-            return { label: "未完成", kind: "error" };
-        case "needs-reconcile":
-            return { label: "需要同步", kind: "warning" };
-        case "cancelled":
-        case "abandoned":
-        case "superseded":
-            return { label: "已停止", kind: "warning" };
-        default:
-            return { label: "状态已更新", kind: "success" };
-    }
-}