@markusylisiurunen/tau 0.3.43 → 0.3.45

package/dist/host/local_session_host.js

@@ -13,7 +13,7 @@ import { hasGoalTurnMetadata } from "../core/utils/user_metadata.js";
 import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, projectSessionProtocolNoticePresentation, } from "../protocol/session_protocol.js";
 import { LEGACY_SESSION_MODEL_CONTEXT_KEY } from "../store/session_snapshot_migrations.js";
 import { ClientToolBroker } from "./client_tool_broker.js";
-import { createExecutionEnvironmentSubagentRuntimeResolver } from "./execution_runtime.js";
+import { createExecutionEnvironmentSubagentPromptResolver } from "./execution_runtime.js";
 import { HostedEphemeralAgentSession } from "./hosted_ephemeral_agent_session.js";
 import { SessionExecBusyError, SessionRetryUnavailableError, } from "./session_host.js";
 const PATH_AUTOCOMPLETE_CACHE_TTL_MS = 5_000;
@@ -124,7 +124,7 @@ export class LocalSessionHost {
             backend: executionEnvironment.getToolExecutionBackend(),
             clientTools: (sessionId) => this.clientToolBroker.getToolDefinitions(sessionId),
             modelResolver: bootstrap.modelResolver,
-            resolveSubagentRuntime: createExecutionEnvironmentSubagentRuntimeResolver({
+            resolveSubagentPrompts: createExecutionEnvironmentSubagentPromptResolver({
                 executionEnvironment,
                 includeAgentContext: this.sessionOptions.includeAgentContext,
                 now: this.sessionOptions.environment.now,
@@ -368,6 +368,8 @@ class LocalHostedSessionHandle {
     draftAssistantMessage;
     messageStates = new Map();
     timeline = { epoch: 1, sequence: 0, items: [] };
+    turns = new Map();
+    pendingAcceptedTurnHistoryEntryIds = new Set();
     tools = new Map();
     operations = new Map();
     agents = new Map();
@@ -485,19 +487,14 @@ class LocalHostedSessionHandle {
                 this.pendingGoalCommit = goal;
             });
             try {
-                const { userHistoryEntryId } = await this.record({
+                const { userHistoryEntryId } = await this.acceptTurn({
                     text: prependGoalPolicy(goal.objective, goal),
                 });
-                if (logicalTurn.cancellationRequested) {
-                    return {
-                        userHistoryEntryId,
-                        turn: await this.cancelLogicalTurn(),
-                    };
-                }
-                return {
-                    userHistoryEntryId,
-                    turn: await this.runTurnNow(logicalTurn, userHistoryEntryId),
-                };
+                const turn = logicalTurn.cancellationRequested
+                    ? await this.cancelLogicalTurn()
+                    : await this.runTurnNow(logicalTurn, userHistoryEntryId);
+                await this.settleTurn(userHistoryEntryId, turn);
+                return { userHistoryEntryId, turn };
             }
             catch (error) {
                 if (this.pendingGoalCommit === goal) {
@@ -526,13 +523,14 @@ class LocalHostedSessionHandle {
                     await this.blockActiveGoal();
                     return { turn: abortedTurnOutcome() };
                 }
-                const { userHistoryEntryId } = await this.record({
+                const { userHistoryEntryId } = await this.acceptTurn({
                     text: buildGoalContinuationText(goal),
                 });
-                if (logicalTurn.cancellationRequested) {
-                    return { turn: await this.cancelLogicalTurn() };
-                }
-                return { turn: await this.runTurnNow(logicalTurn, userHistoryEntryId) };
+                const turn = logicalTurn.cancellationRequested
+                    ? await this.cancelLogicalTurn()
+                    : await this.runTurnNow(logicalTurn, userHistoryEntryId);
+                await this.settleTurn(userHistoryEntryId, turn);
+                return { turn };
             }
             catch (error) {
                 await this.blockActiveGoal().catch(() => undefined);
@@ -550,15 +548,83 @@ class LocalHostedSessionHandle {
     }
     async record(options) {
         this.assertActive();
-        const userHistoryEntryId = await this.session.commitUserText(options.text, options.historyEntryId ? { historyEntryId: options.historyEntryId } : undefined);
+        const historyEntryId = options.historyEntryId === undefined
+            ? undefined
+            : normalizeExplicitHistoryEntryId(options.historyEntryId);
+        if (historyEntryId !== undefined &&
+            (this.turns.has(historyEntryId) ||
+                this.pendingAcceptedTurnHistoryEntryIds.has(historyEntryId))) {
+            throw new Error(`history entry id '${historyEntryId}' belongs to an accepted turn`);
+        }
+        const userHistoryEntryId = await this.session.commitUserText(options.text, historyEntryId === undefined ? undefined : { historyEntryId });
         return {
             snapshot: await this.snapshot(),
             userHistoryEntryId,
         };
     }
+    async acceptTurn(options) {
+        this.assertActive();
+        const userHistoryEntryId = this.createTurnHistoryEntryId(options.historyEntryId);
+        this.pendingAcceptedTurnHistoryEntryIds.add(userHistoryEntryId);
+        try {
+            await this.session.commitUserText(options.text, { historyEntryId: userHistoryEntryId });
+            return { snapshot: await this.snapshot(), userHistoryEntryId };
+        }
+        finally {
+            this.pendingAcceptedTurnHistoryEntryIds.delete(userHistoryEntryId);
+        }
+    }
+    createTurnHistoryEntryId(preferredId) {
+        if (preferredId !== undefined) {
+            const normalizedId = normalizeExplicitHistoryEntryId(preferredId);
+            if (this.turns.has(normalizedId) ||
+                this.pendingAcceptedTurnHistoryEntryIds.has(normalizedId)) {
+                throw new Error(`turn '${normalizedId}' was already accepted`);
+            }
+            return normalizedId;
+        }
+        let id = `history-${randomUUID()}`;
+        const historyEntryIds = new Set(this.session.rawHistoryEntries.map((entry) => entry.id));
+        while (this.turns.has(id) ||
+            this.pendingAcceptedTurnHistoryEntryIds.has(id) ||
+            historyEntryIds.has(id)) {
+            id = `history-${randomUUID()}`;
+        }
+        return id;
+    }
+    async runAcceptedTurn(userHistoryEntryId) {
+        const acceptedTurn = this.turns.get(userHistoryEntryId);
+        if (!acceptedTurn)
+            throw new Error(`turn '${userHistoryEntryId}' was not accepted`);
+        if (acceptedTurn.state === "settled") {
+            throw new Error(`turn '${userHistoryEntryId}' was already settled`);
+        }
+        const turn = await this.runLogicalTurn((logicalTurn) => this.runTurnNow(logicalTurn, userHistoryEntryId));
+        await this.settleTurn(userHistoryEntryId, turn);
+        return { userHistoryEntryId, turn };
+    }
     async runTurn() {
         return await this.runLogicalTurn((logicalTurn) => this.runTurnNow(logicalTurn));
     }
+    async settleTurn(userHistoryEntryId, outcome) {
+        await this.enqueueMutation(async () => {
+            const existing = this.turns.get(userHistoryEntryId);
+            if (!existing) {
+                throw new Error(`turn '${userHistoryEntryId}' was not accepted`);
+            }
+            if (existing.state === "settled") {
+                if (isDeepStrictEqual(existing.outcome, outcome))
+                    return;
+                throw new Error(`turn '${userHistoryEntryId}' was already settled`);
+            }
+            const turn = { userHistoryEntryId, state: "settled", outcome };
+            this.turns.set(userHistoryEntryId, turn);
+            const delta = await this.commitSnapshotPatch("assistant-message", [
+                { type: "turn.set", turn },
+            ]);
+            this.emitDelta(delta);
+        });
+    }
     async retryTurn() {
         const userMessage = this.session.rawHistoryEntries.findLast((entry) => entry.message.role === "user");
         if (userMessage && hasGoalTurnMetadata(userMessage.message)) {
@@ -629,7 +695,7 @@ class LocalHostedSessionHandle {
                     }
                     await this.emitSnapshotResetIfChanged("assistant-message");
                 });
-                this.resolveCommittedLogicalSteering(committedSteering, initialOutcome);
+                await this.resolveCommittedLogicalSteering(committedSteering, initialOutcome);
                 if (logicalTurn.cancellationRequested) {
                     return await this.cancelLogicalTurn();
                 }
@@ -644,7 +710,7 @@ class LocalHostedSessionHandle {
             catch (error) {
                 try {
                     const outcome = await this.cleanupFailedTurn(rootUserMessage.id, error);
-                    this.resolveCommittedLogicalSteering(committedSteering, outcome);
+                    await this.resolveCommittedLogicalSteering(committedSteering, outcome);
                     return outcome;
                 }
                 catch {
@@ -700,10 +766,11 @@ class LocalHostedSessionHandle {
                 applied: submission.applied.then((association) => ({
                     userHistoryEntryId: association.historyEntryId,
                 })),
-                result: submission.result.then((association) => ({
-                    userHistoryEntryId: association.historyEntryId,
-                    turn: turnOutcomeFromResult(association.result, association.result.finalMessage),
-                })),
+                result: submission.result.then(async (association) => {
+                    const turn = turnOutcomeFromResult(association.result, association.result.finalMessage);
+                    await this.settleTurn(association.historyEntryId, turn);
+                    return { userHistoryEntryId: association.historyEntryId, turn };
+                }),
             };
         }
         const logicalTurn = this.activeLogicalTurn;
@@ -1170,7 +1237,14 @@ class LocalHostedSessionHandle {
             if (goal?.status !== "active") {
                 throw new Error("cannot commit logical steering without an active goal");
             }
-            const historyEntryId = await this.session.commitUserText(prependGoalPolicy(formatSteeringUserMessage(submissions.map((submission) => submission.text)), goal));
+            const historyEntryId = this.createTurnHistoryEntryId();
+            this.pendingAcceptedTurnHistoryEntryIds.add(historyEntryId);
+            try {
+                await this.session.commitUserText(prependGoalPolicy(formatSteeringUserMessage(submissions.map((submission) => submission.text)), goal), { historyEntryId });
+            }
+            finally {
+                this.pendingAcceptedTurnHistoryEntryIds.delete(historyEntryId);
+            }
             for (const submission of submissions) {
                 submission.resolveApplied({ userHistoryEntryId: historyEntryId });
             }
@@ -1185,8 +1259,9 @@ class LocalHostedSessionHandle {
             throw error;
         }
     }
-    resolveCommittedLogicalSteering(committed, turn) {
+    async resolveCommittedLogicalSteering(committed, turn) {
         for (const { historyEntryId, submissions } of committed) {
+            await this.settleTurn(historyEntryId, turn);
             for (const submission of submissions) {
                 submission.resolveResult({ userHistoryEntryId: historyEntryId, turn });
             }
@@ -1214,7 +1289,7 @@ class LocalHostedSessionHandle {
             }
             await this.emitSnapshotResetIfChanged("assistant-message");
         });
-        this.resolveCommittedLogicalSteering(committedSteering, outcome);
+        await this.resolveCommittedLogicalSteering(committedSteering, outcome);
         return outcome;
     }
     async commitSnapshot() {
@@ -1378,6 +1453,7 @@ class LocalHostedSessionHandle {
             catalog: structuredClone(this.catalog),
             executionEnvironment: this.executionEnvironment.snapshot(),
             messages,
+            turns: Object.fromEntries(this.turns),
             timeline: structuredClone(this.timeline),
             tools: Object.fromEntries(this.tools),
             operations: Object.fromEntries(this.operations),
@@ -1468,6 +1544,10 @@ class LocalHostedSessionHandle {
             return;
         }
         this.timeline = structuredClone(snapshot.timeline);
+        this.turns.clear();
+        for (const [id, turn] of Object.entries(snapshot.turns)) {
+            this.turns.set(id, structuredClone(turn));
+        }
         this.tools.clear();
         for (const [id, tool] of Object.entries(snapshot.tools)) {
             this.tools.set(id, structuredClone(tool));
@@ -1721,12 +1801,24 @@ class LocalHostedSessionHandle {
             }
             case "user_message": {
                 const pendingGoal = this.pendingGoalCommit;
+                const acceptsTurn = this.pendingAcceptedTurnHistoryEntryIds.has(event.historyEntryId) ||
+                    event.origin === "steering";
+                const turn = acceptsTurn
+                    ? { userHistoryEntryId: event.historyEntryId, state: "running" }
+                    : undefined;
+                if (turn) {
+                    if (this.turns.has(event.historyEntryId)) {
+                        throw new Error(`turn '${event.historyEntryId}' was already accepted`);
+                    }
+                    this.turns.set(event.historyEntryId, turn);
+                }
                 const timelineItem = this.appendMessageTimelineItem(event.historyEntryId, event.message.timestamp);
                 await this.emitPatch("user-message", [
                     this.agentStateChange(),
                     ...(pendingGoal
                         ? [{ type: "goal.set", goal: structuredClone(pendingGoal) }]
                         : []),
+                    ...(turn ? [{ type: "turn.set", turn }] : []),
                     {
                         type: "message.append",
                         message: {
@@ -1738,6 +1830,9 @@ class LocalHostedSessionHandle {
                     },
                     { type: "timeline.append", item: structuredClone(timelineItem) },
                 ], { persist: true });
+                if (turn) {
+                    this.pendingAcceptedTurnHistoryEntryIds.delete(event.historyEntryId);
+                }
                 await this.recordHistoryFailure(this.history.append(this.sessionId, [userHistoryEntry(event.historyEntryId, event.message)], this.historyRemote));
                 if (pendingGoal && this.pendingGoalCommit === pendingGoal) {
                     this.pendingGoalCommit = undefined;
@@ -2266,6 +2361,13 @@ class LocalHostedSessionHandle {
         return { status: "failed", stopReason: "error", errorMessage: diagnostic };
     }
 }
+function normalizeExplicitHistoryEntryId(historyEntryId) {
+    const normalizedId = historyEntryId.trim();
+    if (!normalizedId) {
+        throw new Error("history entry id must not be empty");
+    }
+    return normalizedId;
+}
 function formatErrorDiagnostic(error) {
     const messages = [];
     const seen = new Set();
@@ -2371,6 +2473,16 @@ function normalizeRecoveredSnapshot(snapshot) {
     const legacyAgentState = recovered.agentState.modelContextKey === LEGACY_SESSION_MODEL_CONTEXT_KEY;
     let changed = recovered.lifecycle !== "idle" || legacyAgentState;
     recovered.lifecycle = "idle";
+    for (const [id, turn] of Object.entries(recovered.turns)) {
+        if (turn.state === "running") {
+            changed = true;
+            recovered.turns[id] = {
+                userHistoryEntryId: id,
+                state: "settled",
+                outcome: abortedTurnOutcome(),
+            };
+        }
+    }
     if (recovered.goal?.status === "active") {
         changed = true;
         recovered.goal.status = "blocked";