@tea-agent/loop-agent 0.34.3 → 0.34.5

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

@@ -15,8 +15,9 @@
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle } from "./session-store.js";
-import { projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
+import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
+import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
 import { walkRepoFiles } from "./repo-walk.js";
 import { isSensitivePath, scrubSecrets } from "./explore-tools.js";
@@ -33,6 +34,23 @@ import { projectTaskContext } from "./context-panel.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
 import { openSseResponse, writeSseEvent } from "../operation-sse.js";
+function turnSummary(turn) {
+    return {
+        turnId: turn.turnId,
+        clientRequestId: turn.clientRequestId ?? null,
+        state: turn.state,
+        ordinal: turn.ordinal,
+        createdAt: turn.createdAt,
+        startedAt: turn.startedAt ?? null,
+        finishedAt: turn.finishedAt ?? null,
+        error: turn.error ?? null,
+        abortRequestedAt: turn.abortRequestedAt ?? null,
+    };
+}
+function isTerminalTurnState(state) {
+    return state === "settled" || state === "aborted" || state === "failed";
+}
+const DEFAULT_ABORT_WAIT_MS = 8_000;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -648,13 +666,25 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
     }
     const active = deps.events.getActiveTurn(sessionId);
     const latest = deps.events.latestTurn(sessionId);
+    const runtimeFacts = typeof deps.runtime.getSessionBusyFacts === "function"
+        ? deps.runtime.getSessionBusyFacts(sessionId)
+        : {
+            isStreaming: false,
+            isPromptRunning: false,
+            isCompacting: false,
+            isBashRunning: false,
+        };
     sendJson(res, 200, {
         ok: true,
         state: {
+            // Legacy flat fields retained for older clients.
             activeTurnId: active?.turnId ?? null,
             activeTurnState: active?.state ?? null,
             latestTurnId: latest?.turnId ?? null,
             latestTurnState: latest?.state ?? null,
+            activeTurn: active ? turnSummary(active) : null,
+            latestTurn: latest ? turnSummary(latest) : null,
+            runtime: runtimeFacts,
         },
     });
 }
@@ -862,12 +892,25 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
     // prompt SSE route uses the same durable Turn resource as POST /turns.
     const createdTurn = deps.events.createTurn(sessionId);
     if (!createdTurn.ok) {
+        if (createdTurn.code === "REQUEST_ID_REUSE_CONFLICT") {
+            sendJson(res, 409, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: createdTurn.code,
+                    message: createdTurn.message,
+                },
+            });
+            return;
+        }
         sendJson(res, 409, {
             ok: false,
+            accepted: false,
             error: {
                 code: "TURN_ACTIVE",
-                message: `chat turn already active: ${createdTurn.activeTurn.turnId}`,
+                message: "上一轮仍在运行，已返回当前 activeTurn；请重新连接或稍后再试。",
             },
+            activeTurn: turnSummary(createdTurn.activeTurn),
         });
         return;
     }
@@ -1009,6 +1052,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!gate.ok) {
         sendJson(res, gate.status, {
             ok: false,
+            accepted: false,
             error: { code: gate.code, message: gate.message },
         });
         return;
@@ -1020,6 +1064,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     catch (error) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: {
                 code: "INVALID_INPUT",
                 message: error instanceof Error ? error.message : String(error),
@@ -1028,6 +1073,9 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         return;
     }
     const text = typeof body.text === "string" ? body.text.trim() : "";
+    const clientRequestId = typeof body.clientRequestId === "string" && body.clientRequestId.trim()
+        ? body.clientRequestId.trim()
+        : undefined;
     let images;
     try {
         images = parseChatImages(body.images);
@@ -1035,6 +1083,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     catch (error) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: {
                 code: "INVALID_ATTACHMENT",
                 message: error instanceof Error ? error.message : String(error),
@@ -1045,6 +1094,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!text) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: { code: "INVALID_INPUT", message: "text is required" },
         });
         return;
@@ -1054,6 +1104,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         if (!record) {
             sendJson(res, 404, {
                 ok: false,
+                accepted: false,
                 error: {
                     code: "NOT_FOUND",
                     message: `chat session not found: ${sessionId}`,
@@ -1075,6 +1126,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
             });
             sendJson(res, mapped.status, {
                 ok: false,
+                accepted: false,
                 error: { code: mapped.code, message: mapped.message },
             });
             return;
@@ -1084,6 +1136,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!actionContext) {
         sendJson(res, 503, {
             ok: false,
+            accepted: false,
             error: {
                 code: "CHAT_NO_ACTION_CONTEXT",
                 message: "Chat runtime has no operator action context wired",
@@ -1091,30 +1144,78 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         });
         return;
     }
-    const created = deps.events.createTurn(sessionId);
+    const payloadHash = hashChatTurnPayload({ text, images });
+    const created = deps.events.createTurn(sessionId, {
+        clientRequestId,
+        payloadHash,
+    });
     if (!created.ok) {
+        if (created.code === "REQUEST_ID_REUSE_CONFLICT") {
+            sendJson(res, 409, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: created.code,
+                    message: created.message,
+                },
+            });
+            return;
+        }
         sendJson(res, 409, {
             ok: false,
+            accepted: false,
             error: {
                 code: "TURN_ACTIVE",
-                message: `chat turn already active: ${created.activeTurn.turnId}`,
+                message: "上一轮仍在运行，已返回当前 activeTurn；请重新连接或稍后再试。",
             },
+            activeTurn: turnSummary(created.activeTurn),
         });
         return;
     }
     const turn = created.turn;
+    // Idempotent retry of an already-accepted request: return the same Turn and
+    // never re-run the prompt (even if it already finished).
+    if (created.idempotent) {
+        sendJson(res, 202, {
+            ok: true,
+            accepted: true,
+            idempotent: true,
+            turnId: turn.turnId,
+            ordinal: turn.ordinal,
+            state: turn.state,
+            turn: turnSummary(turn),
+        });
+        return;
+    }
+    const controller = new AbortController();
+    const execution = deps.turnExecutions?.register({
+        sessionId,
+        turnId: turn.turnId,
+        clientRequestId,
+        controller,
+    });
     deps.events.setTurnState(sessionId, turn.turnId, "running");
+    const running = deps.events.getTurn(sessionId, turn.turnId) ?? {
+        ...turn,
+        state: "running",
+    };
     sendJson(res, 202, {
         ok: true,
-        turnId: turn.turnId,
-        ordinal: turn.ordinal,
-        state: "running",
+        accepted: true,
+        idempotent: false,
+        turnId: running.turnId,
+        ordinal: running.ordinal,
+        state: running.state,
+        turn: turnSummary(running),
     });
     // Deliberately detached from the request lifecycle: closing the POST
     // response cannot abort the prompt; clients follow GET /events instead.
+    // Abort ownership lives in the execution registry (real Stop path).
     void (async () => {
         const { runChatTurn } = await import("./session-store.js");
         let firstUserText;
+        let terminalState = "failed";
+        let terminalError;
         try {
             const outcome = await runChatTurn({
                 runtime: deps.runtime,
@@ -1123,6 +1224,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 sessionId,
                 text,
                 images,
+                signal: controller.signal,
                 onUserMessagePersisted: (record) => {
                     const users = record.messages.filter((message) => message.role === "user");
                     if (users.length !== 1)
@@ -1147,24 +1249,142 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 },
             });
             ensureAgentEndEvent(deps, sessionId, turn.turnId);
-            deps.events.setTurnState(sessionId, turn.turnId, outcome.ok ? "settled" : "failed", outcome.error);
-            if (outcome.ok && firstUserText)
-                scheduleAutomaticTitle(deps, { sessionId, turnId: turn.turnId, firstUserText });
+            if (controller.signal.aborted) {
+                terminalState = "aborted";
+                terminalError = {
+                    code: "CLIENT_ABORTED",
+                    message: "turn aborted by client",
+                };
+                deps.events.setTurnState(sessionId, turn.turnId, "aborted", terminalError);
+            }
+            else if (outcome.ok) {
+                terminalState = "settled";
+                deps.events.setTurnState(sessionId, turn.turnId, "settled");
+                if (firstUserText)
+                    scheduleAutomaticTitle(deps, {
+                        sessionId,
+                        turnId: turn.turnId,
+                        firstUserText,
+                    });
+            }
+            else {
+                terminalState = "failed";
+                terminalError = outcome.error;
+                deps.events.setTurnState(sessionId, turn.turnId, "failed", outcome.error);
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            deps.events.append(sessionId, turn.turnId, {
-                kind: "error",
-                data: { message },
-            });
-            ensureAgentEndEvent(deps, sessionId, turn.turnId);
-            deps.events.setTurnState(sessionId, turn.turnId, "failed", {
-                code: "CHAT_TURN_FAILED",
-                message,
+            if (controller.signal.aborted) {
+                terminalState = "aborted";
+                terminalError = {
+                    code: "CLIENT_ABORTED",
+                    message: "turn aborted by client",
+                };
+                ensureAgentEndEvent(deps, sessionId, turn.turnId);
+                deps.events.setTurnState(sessionId, turn.turnId, "aborted", terminalError);
+            }
+            else {
+                terminalState = "failed";
+                terminalError = { code: "CHAT_TURN_FAILED", message };
+                deps.events.append(sessionId, turn.turnId, {
+                    kind: "error",
+                    data: { message },
+                });
+                ensureAgentEndEvent(deps, sessionId, turn.turnId);
+                deps.events.setTurnState(sessionId, turn.turnId, "failed", terminalError);
+            }
+        }
+        finally {
+            execution?.resolveCompletion({
+                ok: terminalState === "settled",
+                state: terminalState,
+                error: terminalError,
             });
+            deps.turnExecutions?.clear(sessionId, turn.turnId);
         }
     })();
 }
+/** Real server-side abort: invokes Pi session.abort via the execution registry. */
+export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            accepted: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    const turn = deps.events.getTurn(sessionId, turnId);
+    if (!turn) {
+        sendJson(res, 404, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `chat turn not found: ${turnId}`,
+            },
+        });
+        return;
+    }
+    if (isTerminalTurnState(turn.state)) {
+        sendJson(res, 200, {
+            ok: true,
+            accepted: true,
+            idempotent: true,
+            turn: turnSummary(turn),
+        });
+        return;
+    }
+    const execution = deps.turnExecutions?.get(sessionId, turnId);
+    if (!execution) {
+        // Active durable Turn without process ownership (restart orphan / detached).
+        const closed = deps.events.setTurnState(sessionId, turnId, "failed", {
+            code: "CHAT_TURN_OWNER_LOST",
+            message: "turn ownership lost; cannot abort a turn this process does not own",
+        });
+        sendJson(res, 409, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "CHAT_TURN_OWNER_LOST",
+                message: "turn ownership lost; cannot abort a turn this process does not own",
+            },
+            turn: closed ? turnSummary(closed) : turnSummary(turn),
+        });
+        return;
+    }
+    deps.events.markAbortRequested?.(sessionId, turnId);
+    if (!execution.controller.signal.aborted)
+        execution.controller.abort();
+    const waited = await (deps.turnExecutions?.waitForCompletion(sessionId, turnId, DEFAULT_ABORT_WAIT_MS) ?? Promise.resolve({ status: "missing" }));
+    if (waited.status === "completed") {
+        const finalTurn = deps.events.getTurn(sessionId, turnId) ??
+            {
+                ...turn,
+                state: waited.outcome.state,
+            };
+        sendJson(res, 200, {
+            ok: true,
+            accepted: true,
+            idempotent: false,
+            turn: turnSummary(finalTurn),
+        });
+        return;
+    }
+    // Timeout or missing completion: keep non-terminal; client reconciles via /state.
+    const pending = deps.events.getTurn(sessionId, turnId) ?? turn;
+    sendJson(res, 202, {
+        ok: false,
+        accepted: false,
+        error: {
+            code: "TURN_ABORT_PENDING",
+            message: "abort requested; turn has not yet reached a terminal state",
+        },
+        turn: turnSummary(pending),
+    });
+}
 export async function handleGetChatTurn(_req, res, deps, sessionId, turnId) {
     const turn = deps.events.getTurn(sessionId, turnId);
     if (!turn) {
@@ -1423,6 +1643,25 @@ async function handleChatFiles(res, deps, sessionId, query) {
         .map((path) => ({ path }));
     sendJson(res, 200, { ok: true, files });
 }
+export async function handleChatCommands(res, deps, sessionId) {
+    try {
+        const commands = typeof deps.runtime.listSlashCommands === "function"
+            ? await deps.runtime.listSlashCommands(sessionId)
+            : [];
+        res.statusCode = 200;
+        res.setHeader("content-type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ ok: true, commands }));
+    }
+    catch (error) {
+        res.statusCode = 200;
+        res.setHeader("content-type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({
+            ok: true,
+            commands: [],
+            warning: error instanceof Error ? error.message : "commands unavailable",
+        }));
+    }
+}
 export async function handleRuntimeContext(res, deps, sessionId) {
     const ensured = await ensureActiveSession(deps, sessionId);
     if (!ensured.ok) {
@@ -1636,6 +1875,159 @@ export async function ensureActiveSession(deps, sessionId) {
     }
     return { ok: true };
 }
+/**
+ * PATCH /sessions/:id/skills/:resourceId/auto-invocation
+ * Persist repo-scoped preference, then try immediate reloadSession when idle.
+ * Busy sessions keep preferenceSaved=true and reloadApplied=false (no abort).
+ */
+export async function handleSkillAutoInvocation(req, res, deps, sessionId, resourceId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    const ensured = await ensureActiveSession(deps, sessionId);
+    if (!ensured.ok) {
+        sendJson(res, ensured.status, {
+            ok: false,
+            error: { code: ensured.code, message: ensured.message },
+        });
+        return;
+    }
+    const id = resourceId.trim();
+    if (!id) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "resourceId is required",
+            },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    if (typeof body.autoInvocationEnabled !== "boolean") {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "autoInvocationEnabled boolean is required",
+            },
+        });
+        return;
+    }
+    const found = await deps.runtime.findSkillByResourceId(sessionId, id);
+    if (!found) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "PI_SKILL_NOT_FOUND",
+                message: `skill resourceId not in current session inventory: ${id}`,
+            },
+        });
+        return;
+    }
+    const prefsPath = deps.appData.resourcePreferences;
+    if (!prefsPath) {
+        sendJson(res, 500, {
+            ok: false,
+            error: {
+                code: "PI_RESOURCE_PREFERENCES_WRITE_FAILED",
+                message: "resourcePreferences path is not configured",
+            },
+        });
+        return;
+    }
+    try {
+        await setSkillAutoInvocationPreference({
+            filePath: prefsPath,
+            resourceId: id,
+            autoInvocationEnabled: body.autoInvocationEnabled,
+        });
+    }
+    catch (error) {
+        if (error instanceof ResourcePreferencesError) {
+            const status = error.code === "PI_RESOURCE_PREFERENCES_MALFORMED" ? 500 : 500;
+            sendJson(res, status, {
+                ok: false,
+                error: { code: error.code, message: error.message },
+            });
+            return;
+        }
+        sendJson(res, 500, {
+            ok: false,
+            error: {
+                code: "PI_RESOURCE_PREFERENCES_WRITE_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const reload = await deps.runtime.reloadSession(sessionId);
+    if (!reload.ok) {
+        if (reload.code === "PI_SESSION_BUSY") {
+            // Preference is durable; do not abort the busy turn or pretend reload applied.
+            sendJson(res, 200, {
+                ok: true,
+                preferenceSaved: true,
+                reloadApplied: false,
+                error: { code: reload.code, message: reload.message },
+            });
+            return;
+        }
+        sendJson(res, reload.code === "PI_SESSION_NOT_FOUND" ? 404 : 500, {
+            ok: false,
+            preferenceSaved: true,
+            reloadApplied: false,
+            error: { code: reload.code, message: reload.message },
+        });
+        return;
+    }
+    let snapshot;
+    try {
+        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
+    }
+    catch (error) {
+        if (sendRuntimeUnavailable(res, error))
+            return;
+        throw error;
+    }
+    if (!snapshot) {
+        sendJson(res, 503, {
+            ok: false,
+            preferenceSaved: true,
+            reloadApplied: true,
+            error: {
+                code: "PI_RUNTIME_UNAVAILABLE",
+                message: `chat session not active after reload: ${sessionId}`,
+            },
+        });
+        return;
+    }
+    sendJson(res, 200, {
+        ok: true,
+        preferenceSaved: true,
+        reloadApplied: true,
+        revision: reload.revision,
+        snapshot,
+    });
+}
 /**
  * POST /sessions/:id/reload (AC-05 / AC-06): official session.reload() with
  * structured busy/failure semantics. Never aborts, never silently queues.
@@ -2551,7 +2943,12 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleMutationHumanGate(req, res, deps, decodeURIComponent(mutationHumanGate[1]));
         return true;
     }
-    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload)$/);
+    const skillAutoInvocation = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/skills\/([^/]+)\/auto-invocation$/);
+    if (method === "PATCH" && skillAutoInvocation) {
+        await handleSkillAutoInvocation(req, res, deps, decodeURIComponent(skillAutoInvocation[1]), decodeURIComponent(skillAutoInvocation[2]));
+        return true;
+    }
+    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload|commands)$/);
     if (m4Route) {
         const id = decodeURIComponent(m4Route[1]);
         const route = m4Route[2];
@@ -2583,6 +2980,10 @@ export async function handleChatRequest(req, res, deps, pathname) {
             await handleReloadSession(req, res, deps, id);
             return true;
         }
+        if (route === "commands" && method === "GET") {
+            await handleChatCommands(res, deps, id);
+            return true;
+        }
     }
     const sessionMainline = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/branch\/mainline$/);
     if (method === "POST" && sessionMainline) {
@@ -2609,6 +3010,11 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleCreateChatTurn(req, res, deps, decodeURIComponent(sessionTurn[1]));
         return true;
     }
+    const sessionTurnAbort = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)\/abort$/);
+    if (method === "POST" && sessionTurnAbort) {
+        await handleAbortChatTurn(req, res, deps, decodeURIComponent(sessionTurnAbort[1]), decodeURIComponent(sessionTurnAbort[2]));
+        return true;
+    }
     const sessionTurnDetail = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)$/);
     if (method === "GET" && sessionTurnDetail) {
         await handleGetChatTurn(req, res, deps, decodeURIComponent(sessionTurnDetail[1]), decodeURIComponent(sessionTurnDetail[2]));