fix: break thinking flow when user is steering the message

AdminForth/1755/i-can't-write-to-this-input-wh

Author: yaroslav8765

custom/composables/agentStore/useAgentSteerQueue.ts

@@ -35,7 +35,21 @@ export function createAgentSteerQueue({
     queue.value = queue.value.filter((item: QueuedMessage) => item.id !== id);
   }
 
-  function injectSteerMessage(text: string) {
+  // Break the assistant's live stream at the steer point: freeze whatever streamed so far
+  // (e.g. the current reasoning block), drop the steer message in, and let the rest stream
+  // into a fresh assistant message after it — so the conversation reads
+  // "reasoning block → steer → new reasoning block" instead of the steer landing next to
+  // the user's original prompt.
+  //
+  // This reaches into the AI SDK's in-flight streaming state (`chat.activeResponse`):
+  //  - reasoning/text parts are looked up by id reference in `active*Parts`, so pointing
+  //    those entries at fresh (empty) parts redirects subsequent deltas past the steer;
+  //  - the stream writer pushes a *new* message whenever `state.message.id` no longer
+  //    matches the last displayed message, so swapping in a new `message` splits the bubble
+  //    without duplicating the frozen block.
+  // If that internal shape isn't present (not streaming, or a future SDK change), we fall
+  // back to inserting the steer just above the streaming assistant.
+  async function injectSteerMessage(text: string) {
     const chat = currentChat.value;
     if (!chat) {
       return;
@@ -46,6 +60,11 @@ export function createAgentSteerQueue({
       parts: [{ type: 'text', text, state: 'done' }],
     };
     const messages = chat.messages;
+
+    if (breakStreamWithSteer(chat, messages, steerMessage)) {
+      return;
+    }
+
     const lastMessage = messages[messages.length - 1];
     if (lastMessage?.role === 'assistant') {
       messages.splice(messages.length - 1, 0, steerMessage);
@@ -54,6 +73,58 @@ export function createAgentSteerQueue({
     }
   }
 
+  function breakStreamWithSteer(chat: Chat<any>, messages: any[], steerMessage: IMessage): boolean {
+    try {
+      const streamingState = (chat as any).activeResponse?.state;
+      const streamingMessage = streamingState?.message;
+      const lastIndex = messages.length - 1;
+      const lastMessage = messages[lastIndex];
+      const isStreamingIntoLastAssistant =
+        streamingMessage?.role === 'assistant'
+        && Array.isArray(streamingMessage.parts)
+        && streamingMessage.parts.length > 0
+        && lastMessage?.role === 'assistant';
+
+      if (!isStreamingIntoLastAssistant) {
+        return false;
+      }
+
+      // 1) Freeze block 1 as a fresh, decoupled assistant message. Copying the parts (and
+      //    reassigning the array slot) detaches it from the SDK's live parts and forces a
+      //    re-render so the block stops showing as "streaming".
+      const frozenParts = streamingMessage.parts.map((part: any) => ({
+        ...part,
+        state: part?.state === 'streaming' ? 'done' : part?.state,
+      }));
+      messages[lastIndex] = { ...streamingMessage, parts: frozenParts };
+      console.log('Frozen parts:', frozenParts);
+      // 2) Redirect the SDK's in-flight reasoning/text parts into a fresh continuation
+      //    message so subsequent deltas (resolved by id reference) land after the steer.
+      const continuation: any = { id: crypto.randomUUID(), role: 'assistant', parts: [] };
+      const redirectActiveParts = (activeParts: Record<string, any> | undefined) => {
+        if (!activeParts) {
+          return;
+        }
+        for (const id of Object.keys(activeParts)) {
+          const continued = { ...activeParts[id], text: '', state: 'streaming' };
+          activeParts[id] = continued;
+          continuation.parts.push(continued);
+        }
+      };
+      redirectActiveParts(streamingState.activeReasoningParts);
+      redirectActiveParts(streamingState.activeTextParts);
+
+      // 3) Hand the SDK the continuation as its streaming message; its next write() pushes
+      //    it as a new assistant bubble. Slot the steer between the frozen block and it.
+      streamingState.message = continuation;
+      messages.push(steerMessage);
+      return true;
+    } catch (error) {
+      console.error('Steer stream-break failed, inserting steer inline instead', error);
+      return false;
+    }
+  }
+
   // Persist the steer by appending it onto the running turn's prompt (display only — the
   // LLM already has it via the running turn + checkpointer, so this never re-enters the
   // model context). The backend adds the marker; the reload path splits it back out.

custom/package.json

@@ -18,7 +18,7 @@
     "@shikijs/langs": "^4.0.2",
     "@shikijs/themes": "^4.0.2",
     "@vueuse/core": "^14.2.1",
-    "ai": "^6.0.168",
+    "ai": "6.0.168",
     "custom-vue-scrollbar": "^0.0.8",
     "dompurify": "^3.3.3",
     "katex": "^0.16.45",