@markusylisiurunen/tau 0.3.21 → 0.3.22

package/dist/tui/session_chat_controller.js

@@ -59,6 +59,8 @@ export class SessionChatController {
     isStreaming = false;
     submittedTurnInProgress = false;
     manualCompactionInProgress = false;
+    localDiffReviewInProgress = false;
+    sessionReplacementInProgress = false;
     isBashMode = false;
     isBashIncognito = false;
     isMemoryMode = false;
@@ -120,8 +122,8 @@ export class SessionChatController {
             startTurnTimer: () => this.startTurnTimer(),
             stopTurnTimer: () => this.stopTurnTimer(),
             getDiffToolConfig: () => this.resolveDiffToolConfig(),
-            startSession: (args) => this.startDiffReviewBridge(args),
-            onReviewReturned: (review) => void this.handleReturnedDiffReview(review),
+            startSession: (args) => this.startDiffReviewBridge(args, this.session, this.snapshot),
+            onReviewReturned: (review) => this.handleReturnedDiffReview(review, this.session),
         });
     }
     start() {
@@ -183,7 +185,7 @@ export class SessionChatController {
         if (!this.isSessionOperationActive()) {
             return true;
         }
-        if (this.manualCompactionInProgress) {
+        if (this.isBlockingSessionOperationActive()) {
             return false;
         }
         const trimmed = text.trimStart();
@@ -221,6 +223,10 @@ export class SessionChatController {
         }
         this.lastEmptySubmitAt = undefined;
         if (this.isSessionOperationActive()) {
+            if (this.isBlockingSessionOperationActive()) {
+                this.view.addSystemMessage("wait for tau to become idle before submitting input", "warn");
+                return;
+            }
             if (trimmed.startsWith("/") && this.isSingleLineInput(text)) {
                 const parsed = this.commandRegistry.parse(trimmed);
                 if (parsed.type !== "unknown") {
@@ -471,6 +477,10 @@ export class SessionChatController {
             await this.submitUserText(trimmed);
             return;
         }
+        if (this.isBlockingSessionOperationActive()) {
+            this.view.addSystemMessage("wait for tau to become idle before submitting input", "warn");
+            return;
+        }
         this.submitSteeringText(trimmed);
     }
     submitQueuedText(text) {
@@ -795,49 +805,88 @@ export class SessionChatController {
     }
     async createNewSession() {
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("cannot create a new session while a turn is running", "warn");
+            this.view.addSystemMessage("cannot create a new session while another session operation is running", "warn");
             return;
         }
         if (!this.createSession) {
             this.view.addSystemMessage("new session creation is unavailable", "error");
             return;
         }
+        const createInput = {
+            executionEnvironment: this.createExecutionEnvironmentInputFromSnapshot(),
+            personaId: this.snapshot.settings.personaId,
+            ...(this.snapshot.settings.reasoning !== undefined
+                ? { reasoning: this.snapshot.settings.reasoning }
+                : {}),
+        };
+        this.sessionReplacementInProgress = true;
+        this.refreshStatus();
+        let nextSession;
+        let nextEventUnsubscribe;
+        let nextPendingUserMessagesUnsubscribe;
+        let installed = false;
         try {
-            const previousUnsubscribe = this.eventUnsubscribe;
-            const previousPendingUserMessagesUnsubscribe = this.pendingUserMessagesUnsubscribe;
-            const previousSession = this.session;
-            const nextSession = await this.createSession({
-                executionEnvironment: this.createExecutionEnvironmentInputFromSnapshot(),
-                personaId: this.snapshot.settings.personaId,
-                ...(this.snapshot.settings.reasoning !== undefined
-                    ? { reasoning: this.snapshot.settings.reasoning }
-                    : {}),
+            nextSession = await this.createSession(createInput);
+            const nextSnapshot = await nextSession.snapshot();
+            const pendingDeltas = [];
+            const pendingUserMessages = [];
+            let forwardEvents = false;
+            nextEventUnsubscribe = nextSession.onDelta((delta) => {
+                if (forwardEvents) {
+                    this.onSdkDelta(delta);
+                }
+                else {
+                    pendingDeltas.push(delta);
+                }
             });
-            this.eventUnsubscribe = undefined;
-            this.pendingUserMessagesUnsubscribe = undefined;
-            previousUnsubscribe?.();
-            previousPendingUserMessagesUnsubscribe?.();
-            try {
-                await previousSession.unobserve();
-            }
-            catch (detachError) {
-                this.view.addSystemMessage(`old session unobserve failed: ${detachError.message}`, "warn");
-            }
+            nextPendingUserMessagesUnsubscribe = nextSession.onPendingUserMessages((message) => {
+                if (forwardEvents) {
+                    this.onSdkPendingUserMessages(message);
+                }
+                else {
+                    pendingUserMessages.push(message);
+                }
+            });
+            const previousSession = this.session;
+            this.eventUnsubscribe?.();
+            this.pendingUserMessagesUnsubscribe?.();
             this.session = nextSession;
-            this.snapshot = await this.session.snapshot();
-            this.observedSessionRevision = this.snapshot.revision;
-            this.eventUnsubscribe = this.session.onDelta((delta) => this.onSdkDelta(delta));
-            this.pendingUserMessagesUnsubscribe = this.session.onPendingUserMessages((message) => this.onSdkPendingUserMessages(message));
+            this.snapshot = nextSnapshot;
+            this.observedSessionRevision = nextSnapshot.revision;
+            this.eventUnsubscribe = nextEventUnsubscribe;
+            this.pendingUserMessagesUnsubscribe = nextPendingUserMessagesUnsubscribe;
+            installed = true;
             this.view.resetToolUiSession();
             this.assistantMessages = [];
             this.startLocalUiSession();
             this.addSessionIdentityMessage();
             this.renderSnapshot(this.snapshot);
-            this.refreshStatus();
+            for (const delta of pendingDeltas) {
+                this.onSdkDelta(delta);
+            }
+            for (const message of pendingUserMessages) {
+                this.onSdkPendingUserMessages(message);
+            }
+            forwardEvents = true;
+            try {
+                await previousSession.unobserve();
+            }
+            catch (detachError) {
+                this.view.addSystemMessage(`old session unobserve failed: ${detachError.message}`, "warn");
+            }
         }
         catch (error) {
+            if (!installed && nextSession) {
+                nextEventUnsubscribe?.();
+                nextPendingUserMessagesUnsubscribe?.();
+                await nextSession.unobserve().catch(() => undefined);
+            }
             this.view.addSystemMessage(`new session failed: ${error.message}`, "error");
         }
+        finally {
+            this.sessionReplacementInProgress = false;
+            this.refreshStatus();
+        }
     }
     createExecutionEnvironmentInputFromSnapshot() {
         const snapshot = this.snapshot.executionEnvironment;
@@ -1158,7 +1207,12 @@ export class SessionChatController {
         this.refreshStatus();
     }
     isSessionOperationActive() {
-        return this.isStreaming || this.submittedTurnInProgress || this.manualCompactionInProgress;
+        return (this.isStreaming || this.submittedTurnInProgress || this.isBlockingSessionOperationActive());
+    }
+    isBlockingSessionOperationActive() {
+        return (this.manualCompactionInProgress ||
+            this.localDiffReviewInProgress ||
+            this.sessionReplacementInProgress);
     }
     async recoverFromRevisionGap() {
         if (this.snapshotRecovery) {
@@ -1652,35 +1706,46 @@ export class SessionChatController {
             this.view.addSystemMessage("wait for tau to become idle before starting /diff.", "warn");
             return;
         }
-        await this.diffReviewService.start(argsText);
+        const session = this.session;
+        const snapshot = this.snapshot;
+        this.localDiffReviewInProgress = true;
+        this.refreshStatus();
+        try {
+            await this.diffReviewService.start(argsText, {
+                startSession: (args) => this.startDiffReviewBridge(args, session, snapshot),
+                onReviewReturned: (review) => this.handleReturnedDiffReview(review, session),
+            });
+        }
+        finally {
+            this.localDiffReviewInProgress = false;
+            this.refreshStatus();
+        }
     }
     isDiffReviewIdle() {
-        return (!this.isStreaming &&
-            !this.submittedTurnInProgress &&
+        return (!this.isSessionOperationActive() &&
             !this.listenRecording &&
             !this.listenTransition &&
             !this.isTranscribingListen &&
-            !this.speakTask &&
-            !this.diffReviewService.isActive());
+            !this.speakTask);
     }
     resolveDiffToolConfig() {
         return this.config.diffTool ?? this.defaultDiffTool;
     }
-    async startDiffReviewBridge(args) {
+    async startDiffReviewBridge(args, session, sessionSnapshot) {
         const snapshot = await captureDiffReviewSnapshot({
-            cwd: this.snapshot.executionEnvironment.cwd,
+            cwd: sessionSnapshot.executionEnvironment.cwd,
             source: args.source,
             signal: args.signal,
-            deps: createSessionDiffReviewSnapshotDeps(this.session),
+            deps: createSessionDiffReviewSnapshotDeps(session),
         });
-        const ephemeral = await this.session.createEphemeralContext({
+        const ephemeral = await session.createEphemeralContext({
             instructions: buildDiffReviewInstructions(snapshot),
             tools: ["bash", "view_image"],
         });
         const bridge = new DiffReviewBridge({
             snapshot,
-            contextWindow: this.snapshot.bootstrap.model.contextWindow,
-            submitThreadMessage: (options) => this.session.submitEphemeralThread({
+            contextWindow: sessionSnapshot.bootstrap.model.contextWindow,
+            submitThreadMessage: (options) => session.submitEphemeralThread({
                 contextId: ephemeral.contextId,
                 threadId: options.threadId,
                 ...(options.forkFromThreadId ? { forkFromThreadId: options.forkFromThreadId } : {}),
@@ -1689,7 +1754,7 @@ export class SessionChatController {
             deps: this.deps,
             ...(this.diffToolLauncher ? { toolLauncher: this.diffToolLauncher } : {}),
         });
-        const unsubscribeEphemeral = this.session.onEphemeral((message) => {
+        const unsubscribeEphemeral = session.onEphemeral((message) => {
             const event = message.event;
             if (event.type !== "ephemeral-agent.thread-update" ||
                 event.contextId !== ephemeral.contextId) {
@@ -1712,18 +1777,18 @@ export class SessionChatController {
         }
         catch (error) {
             unsubscribeEphemeral();
-            await this.session.closeEphemeralContext(ephemeral.contextId).catch(() => undefined);
+            await session.closeEphemeralContext(ephemeral.contextId).catch(() => undefined);
             await bridge.cancel("launch_failed").catch(() => undefined);
             await bridge.close().catch(() => undefined);
             throw error;
         }
         const result = bridge.result.finally(async () => {
             unsubscribeEphemeral();
-            await this.session.closeEphemeralContext(ephemeral.contextId).catch(() => undefined);
+            await session.closeEphemeralContext(ephemeral.contextId).catch(() => undefined);
         });
         return { bridge, result };
     }
-    async handleReturnedDiffReview(review) {
+    async handleReturnedDiffReview(review, session) {
         const model = {
             type: "user",
             text: review.review,
@@ -1734,10 +1799,12 @@ export class SessionChatController {
             this.renderedMessageIds.push(review.historyEntryId);
         }
         try {
-            const result = await this.session.record(formatDiffReviewUserMessage(review), {
+            const result = await session.record(formatDiffReviewUserMessage(review), {
                 historyEntryId: review.historyEntryId,
             });
-            this.syncRenderedHistory(result.snapshot);
+            if (this.session === session) {
+                this.syncRenderedHistory(result.snapshot);
+            }
         }
         catch (error) {
             this.view.addSystemMessage(`failed to add diff review to session: ${error.message}`, "error");