@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.6

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

@@ -53,6 +53,9 @@ export function hydrateSessionThread(raw) {
                 role: "assistant",
                 text: item.text,
                 createdAt,
+                ...(item.kind === "provider-error" && item.providerError
+                    ? { kind: item.kind, providerError: item.providerError }
+                    : {}),
                 ...(content && content.length > 0 ? { content } : {}),
             });
             flushPendingToAssistant(item.id);
@@ -154,9 +157,23 @@ function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolI
 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) {
+    const lastAssistant = group.assistants.at(-1);
+    const finalAssistant = lastAssistant?.kind === "provider-error" ? undefined : lastAssistant;
+    const finalIndex = finalAssistant
+        ? group.assistants.lastIndexOf(finalAssistant)
+        : -1;
+    for (const [index, assistant] of group.assistants.entries()) {
+        if (index === finalIndex)
+            continue;
+        if (assistant.kind === "provider-error" && assistant.providerError) {
+            emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
+            appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+            processItems.push({
+                kind: "provider-error",
+                error: assistant.providerError,
+            });
+            continue;
+        }
         emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
         appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
     }
@@ -292,55 +309,3 @@ export function selectRecentTurnGroups(groups, 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/user-questions.js

@@ -0,0 +1,266 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson } from "../app-data.js";
+function questionFile(root, sessionId) {
+    const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
+    return path.join(root, `${safe}.json`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new Error("ask_user_question requires 1-20 questions");
+    }
+    const ids = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw))
+            throw new Error(`question ${index + 1} must be an object`);
+        const id = typeof raw.id === "string" ? raw.id.trim() : "";
+        const question = typeof raw.question === "string" ? raw.question.trim() : "";
+        if (!id || !question)
+            throw new Error(`question ${index + 1} requires id and question`);
+        if (ids.has(id))
+            throw new Error(`duplicate question id: ${id}`);
+        ids.add(id);
+        const options = raw.options === undefined ? undefined : normalizeOptions(raw.options, id);
+        return {
+            id,
+            question,
+            ...(typeof raw.header === "string" && raw.header.trim()
+                ? { header: raw.header.trim().slice(0, 80) }
+                : {}),
+            ...(typeof raw.detail === "string" && raw.detail.trim()
+                ? { detail: raw.detail.trim().slice(0, 4000) }
+                : {}),
+            ...(options ? { options } : {}),
+            ...(raw.multi_select === true ? { multiSelect: true } : {}),
+        };
+    });
+}
+function normalizeOptions(value, questionId) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 12) {
+        throw new Error(`question ${questionId} options must contain 1-12 items`);
+    }
+    const labels = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw) || typeof raw.label !== "string" || !raw.label.trim()) {
+            throw new Error(`question ${questionId} option ${index + 1} requires a label`);
+        }
+        const label = raw.label.trim();
+        if (labels.has(label))
+            throw new Error(`duplicate option label: ${label}`);
+        labels.add(label);
+        return {
+            label,
+            ...(typeof raw.description === "string" && raw.description.trim()
+                ? { description: raw.description.trim().slice(0, 300) }
+                : {}),
+        };
+    });
+}
+function normalizeAnswer(value, questions) {
+    if (!isRecord(value) || !Array.isArray(value.answers))
+        throw new Error("answers must be an array");
+    const byId = new Map(questions.map((question) => [question.id, question]));
+    const seen = new Set();
+    const answers = value.answers.map((raw) => {
+        if (!isRecord(raw) || typeof raw.id !== "string")
+            throw new Error("answer id is required");
+        const id = raw.id.trim();
+        const question = byId.get(id);
+        if (!question || seen.has(id))
+            throw new Error(`answer does not match question: ${id}`);
+        seen.add(id);
+        const selected = Array.isArray(raw.selected)
+            ? raw.selected.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const allowed = new Set((question.options ?? []).map((option) => option.label));
+        if (selected.some((item) => !allowed.has(item)))
+            throw new Error(`answer contains an unknown option for ${id}`);
+        if (!question.multiSelect && selected.length > 1)
+            throw new Error(`question ${id} accepts one option`);
+        const custom = typeof raw.custom === "string" ? raw.custom.trim().slice(0, 4000) : "";
+        return { id, selected, ...(custom ? { custom } : {}) };
+    });
+    if (seen.size !== questions.length)
+        throw new Error("every question requires an answer or skip entry");
+    return { answers };
+}
+export class UserQuestionRegistry {
+    root;
+    pending = new Map();
+    /** Serialize first-write and resolve/cancel writes for one session. */
+    persistence = new Map();
+    waiters = new Map();
+    turnIds = new Map();
+    listeners = new Set();
+    constructor(root) {
+        this.root = root;
+    }
+    setTurn(sessionId, turnId) {
+        this.turnIds.set(sessionId, turnId);
+    }
+    clearTurn(sessionId) {
+        this.turnIds.delete(sessionId);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async get(sessionId) {
+        const memory = this.pending.get(sessionId);
+        if (memory?.status === "pending")
+            return structuredClone(memory);
+        const disk = await readJsonIfExists(questionFile(this.root, sessionId));
+        if (disk?.status === "pending") {
+            this.pending.set(sessionId, disk);
+            return structuredClone(disk);
+        }
+        return undefined;
+    }
+    async ask(input) {
+        const questions = normalizeQuestions(input.questions);
+        if (input.signal?.aborted)
+            throw new Error("USER_QUESTION_ABORTED");
+        if (await this.get(input.sessionId))
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        // Two tool calls can finish the disk lookup in the same turn. Re-check the
+        // in-memory lease after that await so only the first one can publish.
+        if (this.pending.get(input.sessionId)?.status === "pending") {
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        }
+        const now = new Date().toISOString();
+        const question = {
+            schemaVersion: 1,
+            requestId: `question_${randomBytes(12).toString("hex")}`,
+            sessionId: input.sessionId,
+            toolCallId: input.toolCallId,
+            ...(this.turnIds.get(input.sessionId) ? { turnId: this.turnIds.get(input.sessionId) } : {}),
+            questions,
+            createdAt: now,
+            updatedAt: now,
+            status: "pending",
+            version: 1,
+        };
+        this.pending.set(input.sessionId, question);
+        // Register the waiter before the first persistence await. A turn abort can
+        // arrive while the request is being written; registering afterwards leaves
+        // cancel() with nobody to reject and the tool promise would hang forever.
+        let persisted = false;
+        let abortRequested = false;
+        const waiting = new Promise((resolve, reject) => {
+            const onAbort = () => {
+                abortRequested = true;
+                if (persisted) {
+                    void this.cancel(input.sessionId, question.requestId, "TURN_ABORTED").catch(reject);
+                }
+            };
+            this.waiters.set(input.sessionId, {
+                resolve: (answer) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    resolve(answer);
+                },
+                reject: (error) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    reject(error);
+                },
+            });
+            if (input.signal?.aborted)
+                onAbort();
+            else
+                input.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            await this.persist(input.sessionId, question);
+            persisted = true;
+            if (abortRequested) {
+                await this.cancel(input.sessionId, question.requestId, "TURN_ABORTED");
+                return waiting;
+            }
+            this.emit({ type: "requested", question });
+        }
+        catch (error) {
+            const waiter = this.waiters.get(input.sessionId);
+            this.pending.delete(input.sessionId);
+            this.waiters.delete(input.sessionId);
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (waiter) {
+                waiter.reject(failure);
+                return waiting;
+            }
+            throw failure;
+        }
+        return waiting;
+    }
+    async answer(sessionId, requestId, rawAnswer) {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const answer = normalizeAnswer(rawAnswer, current.questions);
+        const resolved = {
+            ...current,
+            status: "resolved",
+            answer,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, resolved);
+        this.emit({ type: "resolved", question: resolved });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.resolve(answer);
+        return resolved;
+    }
+    async cancel(sessionId, requestId, reason = "USER_CANCELLED") {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const cancelled = {
+            ...current,
+            status: "cancelled",
+            cancelReason: reason,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, cancelled);
+        this.emit({ type: "cancelled", question: cancelled });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.reject(new Error(reason));
+        return cancelled;
+    }
+    async cancelForSession(sessionId, reason = "SESSION_DISPOSED") {
+        const current = await this.get(sessionId);
+        if (current)
+            await this.cancel(sessionId, current.requestId, reason);
+    }
+    emit(change) {
+        for (const listener of this.listeners) {
+            try {
+                listener(change);
+            }
+            catch { /* observers never break the waiter */ }
+        }
+    }
+    async persist(sessionId, question) {
+        const write = writeSecureJson(questionFile(this.root, sessionId), question);
+        this.persistence.set(sessionId, write);
+        try {
+            await write;
+        }
+        finally {
+            if (this.persistence.get(sessionId) === write) {
+                this.persistence.delete(sessionId);
+            }
+        }
+    }
+}

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

@@ -28,6 +28,20 @@ function readWorkspaceParams(query) {
         ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
         ...(read("featureId") ? { featureId: read("featureId") } : {}),
         ...(read("intent") ? { intent: read("intent") } : {}),
+        ...(read("workspaceId") ? { workspaceId: read("workspaceId") } : {}),
+        ...(read("sessionId") ? { sessionId: read("sessionId") } : {}),
+    };
+}
+export function resolveLegacyWorkspaceSelection(location, knownWorkspaceIds) {
+    const parsed = parseConsoleRoute(location);
+    const requested = parsed?.workspaceId?.trim();
+    if (parsed && requested && !knownWorkspaceIds.includes(requested)) {
+        return { status: "unknown-workspace", workspaceId: requested };
+    }
+    return {
+        status: "ok",
+        workspace: parsed?.workspace ?? resolveDefaultLanding({ location }),
+        params: parsed ?? {},
     };
 }
 /** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */

package/dist/worker/console/native-directory-picker.js

@@ -0,0 +1,13 @@
+/**
+ * DSH's native directory-picker adapter.
+ *
+ * The published DSH host package uses the modern Win32 IFileOpenDialog in a
+ * dedicated child process (plus osascript/Zenity/KDialog on other platforms),
+ * so the Console does not pay PowerShell startup cost or lose the chooser
+ * behind the browser window.
+ */
+import { pickNativeDirectory, } from "@deepseek-ai/dsh-host-directory-picker-native";
+/** Open the host OS single-folder chooser. Cancellation is a null result. */
+export async function pickNativeWorkspaceDirectory(signal, internals = {}) {
+    return pickNativeDirectory(signal, internals);
+}