@tea-agent/loop-agent 0.23.1 → 0.24.0

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

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import { scrubSecrets } from "./explore-tools.js";
+function summary(text, max = 320) {
+    if (!text)
+        return undefined;
+    return scrubSecrets(text).scrubbed
+        .replace(/\bghp_[A-Za-z0-9]{20,}\b/g, "[REDACTED]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gi, "Bearer [REDACTED]")
+        .slice(0, max);
+}
+export function projectRuntimeContext(input) {
+    return {
+        readOnly: true,
+        systemPrompt: {
+            hash: createHash("sha256").update(input.systemPrompt).digest("hex"),
+            summary: summary(input.systemPrompt),
+        },
+        skills: input.skills.map((skill) => ({ ...skill, description: summary(skill.description, 200) ?? "" })),
+        resources: { mode: "closed", noContextFiles: true, noSkills: true, noExtensions: true, hasBash: false, activeToolCount: input.activeTools.length },
+        model: input.model,
+        thinkingLevel: input.thinkingLevel,
+        suffix: input.systemPromptSuffix ? { present: true, summary: summary(input.systemPromptSuffix) } : { present: false },
+    };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Pure runtime-selection helpers shared by the Operator Chat UI and tests.
+ *
+ * These functions encode the merge/match semantics between persisted session
+ * runtime state (model + thinking level) and the read-only runtime context
+ * snapshot. They are intentionally side-effect-free so they can be unit-tested
+ * in a plain Node environment (the React component owns the network race
+ * guards; these helpers only define what "matches" and "merged" mean).
+ */
+/** Format a model reference for `<option value>` keys and equality checks. */
+export function formatModelRef(provider, modelId) {
+    return `${provider}/${modelId}`;
+}
+/** Normalize a server record into the optional model/thinking patch fields. */
+export function runtimeSelectionFromRecord(record) {
+    return {
+        ...(record.modelProvider && record.modelId
+            ? { model: { provider: record.modelProvider, modelId: record.modelId } }
+            : {}),
+        ...(record.thinkingLevel ? { thinkingLevel: record.thinkingLevel } : {}),
+    };
+}
+/** Merge a patch onto a session, preferring patch values and keeping the id. */
+export function mergeSessionRuntime(current, patch) {
+    return {
+        ...current,
+        model: patch.model ?? current.model,
+        thinkingLevel: patch.thinkingLevel ?? current.thinkingLevel,
+    };
+}
+/** True when `current` already carries the values in `patch`. */
+export function sessionRuntimeMatches(current, patch) {
+    const next = mergeSessionRuntime(current, patch);
+    return (next.model?.provider === current.model?.provider &&
+        next.model?.modelId === current.model?.modelId &&
+        next.thinkingLevel === current.thinkingLevel);
+}

package/dist/worker/console/chat/session-store.js

@@ -11,9 +11,12 @@
  * operator action call. Every invocation is re-authorized here.
  */
 import path from "node:path";
+import { readdir, rm } from "node:fs/promises";
 import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
 import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
+import { projectOperationForChat } from "./chat-event-store.js";
+import { scrubSecrets } from "./explore-tools.js";
 function recordPath(appData, sessionId) {
     return path.join(appData.chats, `${sessionId}.json`);
 }
@@ -28,8 +31,60 @@ export class ChatSessionStore {
     constructor(appData) {
         this.appData = appData;
     }
+    /** Read + migrate legacy V1 records into the V2 in-memory shape. */
     async get(sessionId) {
-        return readJsonIfExists(recordPath(this.appData, sessionId));
+        const raw = await readJsonIfExists(recordPath(this.appData, sessionId));
+        if (!raw || raw.sessionId !== sessionId)
+            return undefined;
+        return {
+            schemaVersion: 2,
+            sessionId,
+            repoFingerprint: raw.repoFingerprint ?? this.appData.fingerprint,
+            repoRootDisplay: raw.repoRootDisplay ?? this.appData.repoRoot,
+            state: raw.state === "archived" ? "archived" : "active",
+            ...(typeof raw.title === "string" ? { title: raw.title } : {}),
+            ...(typeof raw.sessionFile === "string" ? { sessionFile: raw.sessionFile } : {}),
+            createdAt: raw.createdAt ?? new Date(0).toISOString(),
+            updatedAt: raw.updatedAt ?? raw.createdAt ?? new Date(0).toISOString(),
+            ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
+            ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
+            ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
+            messages: Array.isArray(raw.messages) ? raw.messages : [],
+            toolInvocations: Array.isArray(raw.toolInvocations) ? raw.toolInvocations : [],
+        };
+    }
+    async listMessages(sessionId, options = {}) {
+        const record = await this.get(sessionId);
+        if (!record)
+            throw new Error(`chat session not found: ${sessionId}`);
+        const limit = Math.max(1, Math.min(50, Math.floor(options.limit ?? 30)));
+        const beforeIndex = options.beforeId
+            ? record.messages.findIndex((message) => message.id === options.beforeId)
+            : record.messages.length;
+        const end = beforeIndex < 0 ? record.messages.length : beforeIndex;
+        const start = Math.max(0, end - limit);
+        const messages = record.messages.slice(start, end);
+        return {
+            messages,
+            hasMore: start > 0,
+            ...(messages[0] ? { nextCursor: messages[0].id } : {}),
+        };
+    }
+    /** List repo-bound sessions, newest first. Deleted records are absent. */
+    async list(options) {
+        let names;
+        try {
+            names = await readdir(this.appData.chats);
+        }
+        catch {
+            return [];
+        }
+        const records = await Promise.all(names
+            .filter((name) => name.endsWith(".json"))
+            .map((name) => this.get(name.slice(0, -".json".length))));
+        return records
+            .filter((record) => Boolean(record) && (options?.includeArchived || record.state === "active"))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     /** Serialize a mutating op per session. */
     serialize(sessionId, op) {
@@ -44,8 +99,12 @@ export class ChatSessionStore {
         return this.serialize(input.sessionId, async () => {
             const now = new Date().toISOString();
             const record = {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 sessionId: input.sessionId,
+                repoFingerprint: this.appData.fingerprint,
+                repoRootDisplay: this.appData.repoRoot,
+                state: "active",
+                ...(input.sessionFile ? { sessionFile: input.sessionFile } : {}),
                 createdAt: now,
                 updatedAt: now,
                 modelProvider: input.modelProvider,
@@ -57,6 +116,73 @@ export class ChatSessionStore {
             return record;
         });
     }
+    async forkFrom(input) {
+        const source = await this.get(input.sourceSessionId);
+        if (!source)
+            throw new Error(`chat session not found: ${input.sourceSessionId}`);
+        return this.serialize(input.targetSessionId, async () => {
+            const now = new Date().toISOString();
+            const record = {
+                ...source,
+                sessionId: input.targetSessionId,
+                state: "active",
+                ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
+                createdAt: now,
+                updatedAt: now,
+                messages: structuredClone(source.messages),
+                toolInvocations: structuredClone(source.toolInvocations),
+            };
+            await writeSecureJson(recordPath(this.appData, input.targetSessionId), record);
+            return record;
+        });
+    }
+    async rename(sessionId, title) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            record.title = title.trim().slice(0, 160) || undefined;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async setRuntimeSelection(sessionId, selection) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            if (selection.modelProvider !== undefined)
+                record.modelProvider = selection.modelProvider;
+            if (selection.modelId !== undefined)
+                record.modelId = selection.modelId;
+            if (selection.thinkingLevel !== undefined)
+                record.thinkingLevel = selection.thinkingLevel;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async setState(sessionId, state) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            record.state = state;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async remove(sessionId) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return false;
+            await rm(recordPath(this.appData, sessionId), { force: true });
+            return true;
+        });
+    }
     async appendMessage(sessionId, message) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -94,6 +220,16 @@ export class ChatSessionStore {
  * High-risk actions (contractApply / runDag / etc.) are NOT registered as
  * tools, so they never reach here; but we still deny defensively.
  */
+function redactHumanGateToken(value) {
+    const clone = structuredClone(value);
+    const confirmation = clone.confirmation;
+    if (confirmation && typeof confirmation === "object") {
+        delete confirmation.humanGateToken;
+        delete confirmation.dagBytesPath;
+    }
+    delete clone.humanGateToken;
+    return clone;
+}
 export async function dispatchChatToolCall(ctx, toolName, args, clientRequestId) {
     const decision = authorizeOperatorChatTool(toolName);
     if (!decision.ok) {
@@ -110,25 +246,31 @@ export async function dispatchChatToolCall(ctx, toolName, args, clientRequestId)
         clientRequestId,
     });
     if (result.kind === "accepted") {
-        // Long-running is not in the whitelist, but accepted ops (none currently)
-        // surface a pointer rather than inline data.
+        const canonical = await ctx.operations.get(result.body.operationId);
         return {
             ok: true,
             toolName: decision.toolId,
             result: {
+                schemaVersion: 1,
+                accepted: true,
                 operationId: result.body.operationId,
                 state: result.body.state,
-                note: "operation accepted; poll /api/operator/v1/operations/:id",
+                action: result.body.action,
+                ...(canonical ? { operation: projectOperationForChat(canonical) } : {}),
+                note: "operation accepted; a durable Chat operation reference will follow canonical status",
             },
         };
     }
     const body = result.body;
     const ok = body.ok === true;
     if (ok) {
+        const raw = body.result ?? body;
         return {
             ok: true,
             toolName: decision.toolId,
-            result: body.result ?? body,
+            result: decision.toolId === "prepareDagConfirmation" || decision.toolId === "prepareMutationGate"
+                ? redactHumanGateToken(raw)
+                : raw,
         };
     }
     const error = body.error ?? {};
@@ -168,9 +310,18 @@ export async function runChatTurn(options) {
     // chat history / audit trail is durably written (also makes the outcome
     // observable to tests and to a reconnecting client reading the record).
     const pending = [];
+    let settledEvent;
     try {
         await runtime.prompt(sessionId, text, (event) => {
-            options.onEvent?.(event);
+            if (event.type === "agent_settled") {
+                // The durable operation-ref linker may perform an async canonical
+                // operation read. Hold settled until those writes finish so replay
+                // never observes agent_settled before its accepted operation ref.
+                settledEvent = event;
+            }
+            else {
+                options.onEvent?.(event);
+            }
             switch (event.type) {
                 case "message_update":
                 case "message_end":
@@ -188,6 +339,15 @@ export async function runChatTurn(options) {
                     // that would double-execute every tool call (P0.2).
                     break;
                 case "tool_result": {
+                    const acceptedOperationId = acceptedOperationIdFromResult(event.toolName, event.result);
+                    if (acceptedOperationId && options.onOperationAccepted) {
+                        pending.push(Promise.resolve(options.onOperationAccepted({
+                            sessionId,
+                            toolCallId: event.toolCallId,
+                            toolName: event.toolName,
+                            operationId: acceptedOperationId,
+                        })));
+                    }
                     // tool_execution_end carries the real result of the tool call.
                     // Persist exactly once (the tool message + audit trail). This is
                     // the single point of record for tool outcomes (P0.2).
@@ -212,7 +372,7 @@ export async function runChatTurn(options) {
                     turnError = { code: "CHAT_TURN_ERROR", message: event.message };
                     break;
             }
-        }, { signal: options.signal });
+        }, { signal: options.signal, images: options.images });
     }
     catch (error) {
         await Promise.allSettled(pending);
@@ -220,6 +380,8 @@ export async function runChatTurn(options) {
         return { ok: false, error: { code: "CHAT_TURN_FAILED", message } };
     }
     await Promise.allSettled(pending);
+    if (settledEvent)
+        options.onEvent?.(settledEvent);
     return { ok: !turnError, error: turnError };
 }
 /**
@@ -227,12 +389,49 @@ export async function runChatTurn(options) {
  * huge operator-action payload (e.g. a full dagReport) cannot bloat the chat
  * history record.
  */
+function acceptedOperationIdFromResult(toolName, result) {
+    const candidates = [result];
+    if (result && typeof result === "object") {
+        const record = result;
+        candidates.push(record.details);
+        if (Array.isArray(record.content)) {
+            for (const item of record.content) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const text = item.text;
+                if (typeof text !== "string" || text.length > 16_000)
+                    continue;
+                try {
+                    candidates.push(JSON.parse(text));
+                }
+                catch {
+                    // Only the controlled JSON tool-result envelope is accepted.
+                }
+            }
+        }
+    }
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== "object")
+            continue;
+        const accepted = candidate;
+        if (accepted.schemaVersion === 1 &&
+            accepted.accepted === true &&
+            accepted.action === toolName &&
+            typeof accepted.operationId === "string" &&
+            accepted.operationId.trim()) {
+            return accepted.operationId.trim();
+        }
+    }
+    return undefined;
+}
 function safeStringifyResult(result) {
     try {
-        const str = JSON.stringify(result ?? {});
-        return str.length > 4000 ? `${str.slice(0, 4000)}…[truncated]` : str;
+        const raw = JSON.stringify(result ?? {});
+        const { scrubbed } = scrubSecrets(raw);
+        return scrubbed.length > 4000 ? `${scrubbed.slice(0, 4000)}…[truncated]` : scrubbed;
     }
     catch {
-        return String(result);
+        const { scrubbed } = scrubSecrets(String(result));
+        return scrubbed.length > 4000 ? `${scrubbed.slice(0, 4000)}…[truncated]` : scrubbed;
     }
 }

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

@@ -0,0 +1,15 @@
+export const SHORTCUTS = [
+    { command: "/task", label: "Task context", description: "查看当前任务、Draft 与 assessment", action: "focus-panel:task" },
+    { command: "/contract", label: "Contract", description: "查看 contract diff 与 apply gate", action: "focus-panel:contract" },
+    { command: "/dag", label: "DAG", description: "查看 DAG spine、确认与运行状态", action: "focus-panel:dag" },
+    { command: "/interview", label: "Interview", description: "打开 Requirement Interview", action: "focus:interview" },
+    { command: "/help", label: "Shortcuts", description: "显示可用 shortcut", action: "show-help" },
+];
+/** Pure navigation/display resolver. It deliberately has no mutation decisions. */
+export function resolveShortcut(input) {
+    const token = input.trim().split(/\s+/, 1)[0]?.toLowerCase();
+    if (!token?.startsWith("/"))
+        return undefined;
+    const found = SHORTCUTS.find((shortcut) => shortcut.command === token);
+    return found ? { command: found.command, action: found.action } : { command: token, action: "unknown" };
+}