@markusylisiurunen/tau 0.3.81 → 0.3.83

package/dist/host/local_session_host.js

@@ -4,12 +4,9 @@ import { resolvePromptTemplateWithBackend } from "../core/config/index.js";
 import { assistantHistoryEntries, systemHistoryEntry, toolHistoryEntry, userHistoryEntry, } from "../core/history/transcript.js";
 import { McpManager } from "../core/mcp/manager.js";
 import { ChatRuntime } from "../core/runtime/chat_runtime.js";
-import { formatSteeringUserMessage } from "../core/runtime/steering.js";
-import { buildGoalContinuationText, prependGoalPolicy } from "../core/session/goal.js";
 import { buildToolRunPresentation, TOOL_UI_FACET_VERSION } from "../core/tools/presentation.js";
 import { appendUsageLogEntry, getUsageCostTotal, getUsageTotals, } from "../core/usage/logs.js";
 import { filterProjectPathAutocompleteEntries, loadProjectPathAutocompleteEntriesWithBackend, } from "../core/utils/project_files.js";
-import { hasGoalTurnMetadata } from "../core/utils/user_metadata.js";
 import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, createSessionProtocolSubagentActivitiesMessage, projectSessionProtocolNoticePresentation, projectSessionProtocolSubagentActivity, SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES, } from "../protocol/session_protocol.js";
 import { isIntermediateSystemMessage, } from "../protocol/system_message.js";
 import { LEGACY_SESSION_MODEL_CONTEXT_KEY } from "../store/session_snapshot_migrations.js";
@@ -144,11 +141,6 @@ export class LocalSessionHost {
             promptContext: runtimeContext.promptBootstrap.promptContext,
             eventSink: async (event) => await hostedSession.enqueueRuntimeEvent(event),
             subagentEventSink: async (event) => await hostedSession.recordSubagentEvent(event),
-            goalManager: {
-                getGoal: () => hostedSession.getGoal(),
-                createGoal: async (objective) => await hostedSession.createGoal(objective),
-                updateGoal: async (update) => await hostedSession.updateGoal(update),
-            },
             history: this.history.query(this.historyRemote),
             mcp: this.mcp,
             initialPromptComposition: committedSnapshot
@@ -474,8 +466,6 @@ class LocalHostedSessionHandle {
     disposePromise;
     disposing = false;
     costTotal = 0;
-    goal;
-    pendingGoalCommit;
     forceNextSnapshotRevision;
     projectionFailure;
     disposed = false;
@@ -499,7 +489,6 @@ class LocalHostedSessionHandle {
         this.persistedSnapshot = committedSnapshot
             ? cloneSessionProtocolSnapshot(committedSnapshot)
             : undefined;
-        this.goal = structuredClone(committedSnapshot?.goal ?? null);
         this.forceNextSnapshotRevision = forceNextSnapshotRevision;
         this.restoreProtocolState(committedSnapshot);
         this.committedSnapshot = committedSnapshot
@@ -510,8 +499,7 @@ class LocalHostedSessionHandle {
         return this.runtime.isTurnRunning;
     }
     get canAcceptSteering() {
-        return (this.runtime.isTurnRunning ||
-            Boolean(this.activeLogicalTurn && this.goal?.status === "active"));
+        return this.runtime.isTurnRunning;
     }
     get sessionId() {
         return this.session.sessionId;
@@ -546,105 +534,6 @@ class LocalHostedSessionHandle {
             this.subagentActivitiesListeners.delete(handler);
         };
     }
-    getGoal() {
-        return structuredClone(this.goal);
-    }
-    async createGoal(objective) {
-        const goal = this.buildNewGoal(objective);
-        await this.setGoal(goal);
-        return structuredClone(goal);
-    }
-    async updateGoal(update) {
-        this.assertActive();
-        const current = this.goal;
-        if (!current) {
-            throw new Error("no goal exists");
-        }
-        if (update.objective !== undefined && update.status === "complete") {
-            throw new Error("goal objective cannot be updated while completing the goal");
-        }
-        if (update.status === "complete") {
-            await this.setGoal(null);
-            return null;
-        }
-        const objective = update.objective?.trim() ?? current.objective;
-        if (!objective) {
-            throw new Error("goal objective must not be empty");
-        }
-        const goal = {
-            objective,
-            status: update.status ?? current.status,
-        };
-        await this.setGoal(goal);
-        return structuredClone(goal);
-    }
-    async startGoal(objective) {
-        const goal = this.buildNewGoal(objective);
-        return await this.runLogicalTurn(async (logicalTurn) => {
-            await this.enqueueMutation(() => {
-                this.goal = goal;
-                this.pendingGoalCommit = goal;
-            });
-            try {
-                const { userHistoryEntryId } = await this.acceptTurn({
-                    text: prependGoalPolicy(goal.objective, goal),
-                });
-                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) {
-                    await this.enqueueMutation(() => {
-                        this.goal = null;
-                        this.pendingGoalCommit = undefined;
-                    });
-                }
-                else {
-                    await this.blockActiveGoal().catch(() => undefined);
-                }
-                throw error;
-            }
-        });
-    }
-    async resumeGoal() {
-        this.assertActive();
-        if (this.goal?.status !== "blocked") {
-            throw new Error(this.goal ? "goal is already active" : "no goal exists");
-        }
-        const goal = { ...this.goal, status: "active" };
-        return await this.runLogicalTurn(async (logicalTurn) => {
-            await this.setGoal(goal);
-            try {
-                if (logicalTurn.cancellationRequested) {
-                    await this.blockActiveGoal();
-                    return { turn: abortedTurnOutcome() };
-                }
-                const { userHistoryEntryId } = await this.acceptTurn({
-                    text: buildGoalContinuationText(goal),
-                });
-                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);
-                throw error;
-            }
-        });
-    }
-    async clearGoal() {
-        this.assertActive();
-        if (!this.goal) {
-            throw new Error("no goal exists");
-        }
-        await this.setGoal(null);
-        return await this.snapshot();
-    }
     async record(options) {
         this.assertActive();
         const historyEntryId = options.historyEntryId === undefined
@@ -726,9 +615,6 @@ class LocalHostedSessionHandle {
     }
     async retryTurn() {
         const userMessage = this.session.rawHistoryEntries.findLast((entry) => entry.message.role === "user");
-        if (userMessage && hasGoalTurnMetadata(userMessage.message)) {
-            throw new SessionRetryUnavailableError("goal-controlled turns cannot be retried; resume a blocked goal or start a new goal");
-        }
         if (!userMessage) {
             throw new SessionRetryUnavailableError("no user turn is available to retry");
         }
@@ -741,7 +627,6 @@ class LocalHostedSessionHandle {
         }
         const logicalTurn = {
             cancellationRequested: false,
-            pendingSteering: [],
         };
         this.activeLogicalTurn = logicalTurn;
         const run = execute(logicalTurn);
@@ -751,7 +636,6 @@ class LocalHostedSessionHandle {
         }
         finally {
             if (this.activeTurnPromise === run) {
-                this.rejectBufferedLogicalSteering(logicalTurn, new Error("steering was not applied before the logical turn ended"));
                 this.activeTurnPromise = undefined;
                 this.activeLogicalTurn = undefined;
                 await this.enqueueSnapshotResetIfChanged("assistant-message");
@@ -765,58 +649,20 @@ class LocalHostedSessionHandle {
         if (!rootUserMessage) {
             throw new Error("cannot run a turn without a user message");
         }
-        let goalRootHistoryEntryId = this.goal?.status === "active" ? rootUserMessage.id : undefined;
-        while (true) {
-            if (logicalTurn.cancellationRequested) {
-                return await this.cancelLogicalTurn();
-            }
-            const committedSteering = [];
-            try {
-                while (logicalTurn.pendingSteering.length > 0) {
-                    committedSteering.push(await this.commitBufferedLogicalSteering(logicalTurn));
-                }
-                if (logicalTurn.cancellationRequested) {
-                    return await this.cancelLogicalTurn(committedSteering);
-                }
-                const result = await this.runtime.runTurn();
-                const terminalResult = result.terminalResult;
-                if (terminalResult.aborted && this.draftAssistantMessage) {
-                    await this.interruptDraftAssistantMessage();
-                }
-                const initialOutcome = turnOutcomeFromResult(result, result.finalMessage);
-                const terminalOutcome = turnOutcomeFromResult(terminalResult, terminalResult.finalMessage);
-                await this.enqueueMutation(async () => {
-                    if (this.goal?.status === "active") {
-                        goalRootHistoryEntryId ??= rootUserMessage.id;
-                    }
-                    if (terminalOutcome.status !== "completed" && this.goal?.status === "active") {
-                        this.goal = { ...this.goal, status: "blocked" };
-                    }
-                    await this.emitSnapshotResetIfChanged("assistant-message");
-                });
-                await this.resolveCommittedLogicalSteering(committedSteering, initialOutcome);
-                if (logicalTurn.cancellationRequested) {
-                    return await this.cancelLogicalTurn();
-                }
-                if (terminalOutcome.status !== "completed" || this.goal?.status !== "active") {
-                    return goalRootHistoryEntryId ? terminalOutcome : initialOutcome;
-                }
-                if (logicalTurn.pendingSteering.length > 0) {
-                    continue;
-                }
-                await this.session.commitUserText(buildGoalContinuationText(this.goal));
-            }
-            catch (error) {
-                try {
-                    const outcome = await this.cleanupFailedTurn(rootUserMessage.id, error);
-                    await this.resolveCommittedLogicalSteering(committedSteering, outcome);
-                    return outcome;
-                }
-                catch {
-                    this.rejectCommittedLogicalSteering(committedSteering, error);
-                    throw error;
-                }
+        if (logicalTurn.cancellationRequested)
+            return abortedTurnOutcome();
+        try {
+            const result = await this.runtime.runTurn();
+            if (result.terminalResult.aborted && this.draftAssistantMessage) {
+                await this.interruptDraftAssistantMessage();
             }
+            await this.enqueueSnapshotResetIfChanged("assistant-message");
+            return logicalTurn.cancellationRequested
+                ? abortedTurnOutcome()
+                : turnOutcomeFromResult(result, result.finalMessage);
+        }
+        catch (error) {
+            return await this.cleanupFailedTurn(rootUserMessage.id, error);
         }
     }
     interruptTurn() {
@@ -869,29 +715,22 @@ class LocalHostedSessionHandle {
                     const turn = turnOutcomeFromResult(association.result, association.result.finalMessage);
                     await this.settleTurn(association.historyEntryId, turn);
                     return { userHistoryEntryId: association.historyEntryId, turn };
+                }, async (error) => {
+                    const association = await submission.applied;
+                    await this.settleTurn(association.historyEntryId, {
+                        status: "failed",
+                        stopReason: "error",
+                        errorMessage: formatErrorDiagnostic(error),
+                    });
+                    throw error;
                 }),
             };
         }
-        const logicalTurn = this.activeLogicalTurn;
-        if (!logicalTurn || this.goal?.status !== "active") {
-            throw new Error("cannot steer without an active turn");
-        }
-        return this.bufferLogicalSteering(logicalTurn, text);
+        throw new Error("cannot steer without an active turn");
     }
     cancelSteering() {
         this.assertActive();
-        const cancelled = this.runtime.cancelSteering();
-        const logicalTurn = this.activeLogicalTurn;
-        if (!logicalTurn) {
-            return cancelled;
-        }
-        const buffered = logicalTurn.pendingSteering.splice(0);
-        const error = new Error("steering submission was cancelled");
-        for (const submission of buffered) {
-            submission.rejectApplied(error);
-            submission.rejectResult(error);
-        }
-        return [...cancelled, ...buffered.map(({ id, text }) => ({ id, text }))];
+        return this.runtime.cancelSteering();
     }
     async exec(options) {
         return await this.runExec(options.execId, options.signal, async (signal) => {
@@ -1270,123 +1109,6 @@ class LocalHostedSessionHandle {
             throw new AggregateError(errors, "failed to dispose hosted session");
         }
     }
-    buildNewGoal(objective) {
-        this.assertActive();
-        if (this.goal) {
-            throw new Error("a goal already exists; clear it before creating another");
-        }
-        const normalized = objective.trim();
-        if (!normalized) {
-            throw new Error("goal objective must not be empty");
-        }
-        return { objective: normalized, status: "active" };
-    }
-    async setGoal(goal) {
-        await this.enqueueMutation(async () => {
-            await this.emitPatch("goal", [{ type: "goal.set", goal: structuredClone(goal) }]);
-            this.goal = structuredClone(goal);
-        });
-    }
-    async blockActiveGoal() {
-        if (this.goal?.status === "active") {
-            await this.setGoal({ ...this.goal, status: "blocked" });
-        }
-    }
-    bufferLogicalSteering(logicalTurn, text) {
-        const normalized = text.trim();
-        if (!normalized) {
-            throw new Error("steering input must not be empty");
-        }
-        let resolveApplied;
-        let rejectApplied;
-        const applied = new Promise((resolve, reject) => {
-            resolveApplied = resolve;
-            rejectApplied = reject;
-        });
-        let resolveResult;
-        let rejectResult;
-        const result = new Promise((resolve, reject) => {
-            resolveResult = resolve;
-            rejectResult = reject;
-        });
-        const submission = {
-            id: `logical-steering-${randomUUID()}`,
-            text: normalized,
-            applied,
-            result,
-            resolveApplied,
-            resolveResult,
-            rejectApplied,
-            rejectResult,
-        };
-        logicalTurn.pendingSteering.push(submission);
-        return { id: submission.id, applied, result };
-    }
-    async commitBufferedLogicalSteering(logicalTurn) {
-        const submissions = logicalTurn.pendingSteering.splice(0);
-        if (submissions.length === 0) {
-            throw new Error("cannot commit empty logical steering");
-        }
-        try {
-            const goal = this.goal;
-            if (goal?.status !== "active") {
-                throw new Error("cannot commit logical steering without an active 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 });
-            }
-            return { historyEntryId, submissions };
-        }
-        catch (error) {
-            const steeringError = error instanceof Error ? error : new Error(String(error));
-            for (const submission of submissions) {
-                submission.rejectApplied(steeringError);
-                submission.rejectResult(steeringError);
-            }
-            throw error;
-        }
-    }
-    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 });
-            }
-        }
-    }
-    rejectCommittedLogicalSteering(committed, error) {
-        const steeringError = error instanceof Error ? error : new Error(String(error));
-        for (const { submissions } of committed) {
-            for (const submission of submissions) {
-                submission.rejectResult(steeringError);
-            }
-        }
-    }
-    rejectBufferedLogicalSteering(logicalTurn, error) {
-        for (const submission of logicalTurn.pendingSteering.splice(0)) {
-            submission.rejectApplied(error);
-            submission.rejectResult(error);
-        }
-    }
-    async cancelLogicalTurn(committedSteering = []) {
-        const outcome = abortedTurnOutcome();
-        await this.enqueueMutation(async () => {
-            if (this.goal?.status === "active") {
-                this.goal = { ...this.goal, status: "blocked" };
-            }
-            await this.emitSnapshotResetIfChanged("assistant-message");
-        });
-        await this.resolveCommittedLogicalSteering(committedSteering, outcome);
-        return outcome;
-    }
     async commitSnapshot(options = {}) {
         this.assertNotDisposed();
         this.reconcileProjections(options);
@@ -1514,7 +1236,6 @@ class LocalHostedSessionHandle {
                     : {}),
             },
             lifecycle: this.activeTurnPromise || this.runtime.isTurnRunning ? "running" : "idle",
-            goal: structuredClone(this.goal),
             costTotal: this.costTotal,
             settings: {
                 personaId: this.runtime.persona.id,
@@ -1695,7 +1416,6 @@ class LocalHostedSessionHandle {
                 return await mutation();
             }
             catch (error) {
-                this.goal = structuredClone(this.committedSnapshot.goal);
                 this.restoreProtocolState(this.committedSnapshot);
                 throw error;
             }
@@ -1934,7 +1654,6 @@ class LocalHostedSessionHandle {
                 return;
             }
             case "user_message": {
-                const pendingGoal = this.pendingGoalCommit;
                 const acceptsTurn = this.pendingAcceptedTurnHistoryEntryIds.has(event.historyEntryId) ||
                     event.origin === "steering";
                 const turn = acceptsTurn
@@ -1949,9 +1668,6 @@ class LocalHostedSessionHandle {
                 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",
@@ -1968,9 +1684,6 @@ class LocalHostedSessionHandle {
                     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;
-                }
                 return;
             }
             case "history_rewound": {
@@ -2497,9 +2210,6 @@ class LocalHostedSessionHandle {
                 reason: "runtime-error",
                 message: diagnostic,
             });
-            if (this.goal?.status === "active") {
-                this.goal = { ...this.goal, status: "blocked" };
-            }
             const timestamp = Date.now();
             for (const [id, tool] of this.tools) {
                 if (tool.status !== "queued" && tool.status !== "running") {
@@ -2639,10 +2349,6 @@ function normalizeRecoveredSnapshot(snapshot) {
             };
         }
     }
-    if (recovered.goal?.status === "active") {
-        changed = true;
-        recovered.goal.status = "blocked";
-    }
     if (Object.keys(recovered.agents).length > 0) {
         changed = true;
         recovered.agents = {};