@tea-agent/loop-agent 0.44.0-next.3 → 0.44.0-next.5

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;
+}

package/dist/worker/console/chat/pi-runtime.js

@@ -297,6 +297,35 @@ export function createWizardLocalHeadersExtension(options) {
 export { THINKING_LEVELS, RuntimeSnapshotUnavailableError, projectRuntimeSnapshot, };
 export { createDefaultPiSdkBindings } from "./pi-runtime/sdk-bindings.js";
 export { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage };
+export function buildRequestContextEvent(input) {
+    const systemPrompt = input.session.state?.systemPrompt ?? input.session.systemPrompt ?? "";
+    const activeTools = input.session.getActiveToolNames()
+        .filter((name) => typeof name === "string" && name.trim())
+        .slice(0, 256);
+    const provider = input.session.model?.provider;
+    const modelId = input.session.model?.modelId ?? input.session.model?.id;
+    const sources = ["system", "conversation"];
+    if (activeTools.length > 0)
+        sources.push("tools");
+    if (input.imageCount > 0)
+        sources.push("images");
+    return {
+        type: "request_context",
+        sessionId: input.sessionId,
+        requestId: `${input.turnId}:request:1`,
+        step: 1,
+        ...(provider && modelId ? { model: { provider, modelId } } : {}),
+        ...(input.session.thinkingLevel
+            ? { thinkingLevel: input.session.thinkingLevel }
+            : {}),
+        systemPromptHash: createHash("sha256").update(systemPrompt).digest("hex"),
+        systemPromptChars: systemPrompt.length,
+        activeTools,
+        inputChars: input.text.length,
+        imageCount: input.imageCount,
+        sources,
+    };
+}
 function readSessionManagerId(manager) {
     if (!manager || typeof manager !== "object")
         return undefined;
@@ -1977,6 +2006,14 @@ export class ConsolePiRuntime {
             };
             emitContextUsage();
             await this.runPrePromptCompaction(sessionId, session, text, options?.images?.length ?? 0, onEvent);
+            onEvent(buildRequestContextEvent({
+                sessionId,
+                turnId: options?.turnId ?? `${sessionId}:active`,
+                session,
+                text,
+                imageCount: options?.images?.length ?? 0,
+            }));
+            let step = 0;
             let stepStartedAt;
             let firstTokenAt;
             let pendingProviderError;
@@ -1985,12 +2022,24 @@ export class ConsolePiRuntime {
             const emitPendingProviderError = () => {
                 if (!pendingProviderError)
                     return;
-                onEvent(pendingProviderError);
+                const error = pendingProviderError;
+                onEvent(error);
+                onEvent({
+                    type: "turn_error",
+                    sessionId,
+                    step: Math.max(1, step),
+                    ...(error.providerError.code === undefined
+                        ? {}
+                        : { code: String(error.providerError.code) }),
+                    message: error.message,
+                });
                 pendingProviderError = undefined;
                 providerErrorEmitted = true;
             };
             unsub = session.subscribe((event) => {
                 const observedAt = Date.now();
+                if (event.type === "turn_start")
+                    step += 1;
                 if (event.type === "message_start" && isUserSdkMessage(event.message)) {
                     if (!initialUserMessageStarted) {
                         // The first user message_start belongs to session.prompt(text), not
@@ -2021,7 +2070,7 @@ export class ConsolePiRuntime {
                 const compactionId = event.type === "compaction_start" || event.type === "compaction_end"
                     ? activeCompaction?.compactionId ?? newCompactionId(sessionId)
                     : undefined;
-                const mapped = mapSdkEvent(sessionId, event, compactionId);
+                const mapped = mapSdkEvent(sessionId, event, compactionId, Math.max(1, step));
                 if (event.type === "compaction_end")
                     activeCompaction = undefined;
                 if (mapped?.type === "error") {
@@ -2046,7 +2095,7 @@ export class ConsolePiRuntime {
                 if (mapped?.type === "agent_settled") {
                     emitPendingProviderError();
                 }
-                if (mapped?.type === "agent_start") {
+                if (mapped?.type === "step_start" || mapped?.type === "agent_start") {
                     stepStartedAt = observedAt;
                     firstTokenAt = undefined;
                 }
@@ -2074,6 +2123,13 @@ export class ConsolePiRuntime {
                                 : { outputTokens: usage.outputTokens }),
                         };
                     onEvent({ ...mapped, ...(timing ? { timing } : {}) });
+                    if (mapped.stopReason === "length") {
+                        onEvent({
+                            type: "turn_max_tokens",
+                            sessionId,
+                            step: mapped.step ?? Math.max(1, step),
+                        });
+                    }
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
                     emitContextUsage();
@@ -2331,7 +2387,7 @@ export class ConsolePiRuntime {
             this.dbConnections.dispose();
     }
 }
-function mapAssistantMessageEvent(type, sessionId, message) {
+function mapAssistantMessageEvent(type, sessionId, message, step) {
     const record = message !== null && typeof message === "object"
         ? message
         : undefined;
@@ -2355,6 +2411,10 @@ function mapAssistantMessageEvent(type, sessionId, message) {
         sessionId,
         text: extractAssistantText(message),
         ...(content.length > 0 ? { content } : {}),
+        step,
+        ...(type === "message_end" && typeof record?.stopReason === "string"
+            ? { stopReason: record.stopReason }
+            : {}),
     };
 }
 function isUserSdkMessage(message) {
@@ -2362,10 +2422,12 @@ function isUserSdkMessage(message) {
         typeof message === "object" &&
         message.role === "user");
 }
-function mapSdkEvent(sessionId, event, compactionId) {
+export function mapSdkEvent(sessionId, event, compactionId, step = 1) {
     switch (event.type) {
         case "agent_start":
             return { type: "agent_start", sessionId };
+        case "turn_start":
+            return { type: "step_start", sessionId, step };
         case "agent_end":
             return {
                 type: "agent_end",
@@ -2375,15 +2437,50 @@ function mapSdkEvent(sessionId, event, compactionId) {
         case "message_update":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_update", sessionId, event.message);
+            return mapAssistantMessageEvent("message_update", sessionId, event.message, step);
         case "message_end":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_end", sessionId, event.message);
-        case "turn_end":
-            // Usage is emitted from message_end (see prompt subscribe). turn_end
-            // carries the same final assistant message and would double-count.
-            return undefined;
+            return mapAssistantMessageEvent("message_end", sessionId, event.message, step);
+        case "turn_end": {
+            const record = event.message && typeof event.message === "object"
+                ? event.message
+                : undefined;
+            const reason = record?.stopReason;
+            return {
+                type: "step_end",
+                sessionId,
+                step,
+                outcome: reason === "error"
+                    ? "failed"
+                    : reason === "aborted"
+                        ? "interrupted"
+                        : "completed",
+            };
+        }
+        case "auto_retry_start":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                maxAttempts: event.maxAttempts,
+                delayMs: event.delayMs,
+                errorMessage: redactRuntimeText(event.errorMessage, 600),
+                state: "scheduled",
+            };
+        case "auto_retry_end":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                state: event.success ? "completed" : "failed",
+                success: event.success,
+                ...(event.finalError
+                    ? { errorMessage: redactRuntimeText(event.finalError, 600) }
+                    : {}),
+            };
         case "tool_execution_start":
             return {
                 type: "tool_call",
@@ -2391,6 +2488,10 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
                 args: event.args,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
             };
         case "tool_execution_end":
             return {
@@ -2400,6 +2501,10 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolName: event.toolName,
                 result: event.result,
                 isError: event.isError,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
             };
         case "agent_settled":
             return { type: "agent_settled", sessionId };
@@ -2446,8 +2551,19 @@ function mapSdkEvent(sessionId, event, compactionId) {
                     : {}),
             };
         }
-        default:
+        case "message_start":
+        case "queue_update":
             return undefined;
+        default:
+            {
+                const unknownEvent = event;
+                return {
+                    type: "unknown",
+                    sessionId,
+                    eventType: String(unknownEvent.type ?? "unknown"),
+                    value: unknownEvent,
+                };
+            }
     }
 }
 function newCompactionId(sessionId) {

package/dist/worker/console/chat/provider-error.js

@@ -85,15 +85,3 @@ export function parseProviderError(value) {
         category: classify({ message, raw, code }),
     };
 }
-export function providerErrorTitle(category) {
-    switch (category) {
-        case "authentication":
-            return "认证失败";
-        case "context-overflow":
-            return "上下文过大";
-        case "rate-limit":
-            return "请求过于频繁";
-        default:
-            return "Provider 请求失败";
-    }
-}

package/dist/worker/console/chat/repo-browser.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, open, readdir } from "node:fs/promises";
+import { sameFileIdentity } from "../../../shared/file-identity.js";
 import path from "node:path";
 import { guardReadPath, isSensitivePath, scrubSecrets, } from "./explore-tools.js";
 const TREE_LIMIT = 500;
@@ -143,8 +144,7 @@ export async function readRepoPreview(repoRoot, rawPath) {
                 throw new RepoBrowserError(403, guardedCode(rechecked.code), "file path changed while it was being opened");
             const current = await lstat(rechecked.abs);
             if (current.isSymbolicLink() ||
-                current.dev !== info.dev ||
-                current.ino !== info.ino)
+                !sameFileIdentity(info, current))
                 throw new RepoBrowserError(403, "OUT_OF_REPO", "file identity changed while it was being opened");
             size = info.size;
             const readSize = Math.min(size, TEXT_PREVIEW_LIMIT);
@@ -204,8 +204,7 @@ export async function readRepoHtmlAsset(repoRoot, rawPath) {
                 throw new RepoBrowserError(403, guardedCode(rechecked.code), "file path changed while it was being opened");
             const current = await lstat(rechecked.abs);
             if (current.isSymbolicLink() ||
-                current.dev !== info.dev ||
-                current.ino !== info.ino)
+                !sameFileIdentity(info, current))
                 throw new RepoBrowserError(403, "OUT_OF_REPO", "file identity changed while it was being opened");
             return {
                 body: await handle.readFile(),