@adminforth/agent 2.1.0 → 2.2.0

package/dist/application/runTurnUseCase.d.ts

@@ -1,5 +1,6 @@
 import { type IAdminForth } from "adminforth";
 import type { AgentSessionStore } from "../persistence/sessionStore.js";
+import type { SteerBuffer } from "../domain/steerBuffer.js";
 import type { PluginOptions } from "../types.js";
 import type { LlmPort } from "./ports.js";
 import type { DebugSink, HandleTurnInput, PendingInterrupt, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "../domain/turnTypes.js";
@@ -33,6 +34,8 @@ export declare function buildResumeValue(input: {
 export type RunTurnUseCaseDeps = {
     llm: LlmPort;
     sessions: AgentSessionStore;
+    /** Per-session buffer of mid-turn steering instructions; cleared when a turn ends unconsumed. */
+    steerBuffer: SteerBuffer;
     modes: PluginOptions["modes"];
     getAdminforth: () => IAdminForth;
     getAgentSystemPrompt: () => Promise<string>;

package/dist/application/runTurnUseCase.js

@@ -271,6 +271,12 @@ export class RunTurnUseCase {
                 return { text: fullResponse };
             }
             finally {
+                // When the turn is interrupted for HITL approval it will resume, so any steers
+                // buffered meanwhile must survive to be applied on resume. Otherwise the turn is
+                // done and leftover (unconsumed) steers must not leak into the next turn.
+                if (!interrupted) {
+                    this.deps.steerBuffer.clear(prepared.sessionId);
+                }
                 if (!this.deps.hasPersistentCheckpointer && !interrupted) {
                     this.pendingInterrupts.delete(prepared.sessionId);
                 }

package/dist/custom/ChatFooter.vue

@@ -7,27 +7,30 @@
       transition: `transform ${agentTransitions.TRANSITION_DURATION}ms ease-in-out`
     }"            
   >
-    <div 
-      class="w-full border rounded-lg pb-8"
-      :class="agentStore.isAudioChatMode ? 'border-none mt-8' : 'border dark:bg-gray-700'"  
-    > 
+    <SteerQueue />
+    <!-- <SteerDebugPanel /> -->
+    <div
+      class="w-full border rounded-lg flex flex-col"
+      :class="agentStore.isAudioChatMode ? 'border-none mt-8' : 'border dark:bg-gray-700'"
+    >
       <textarea
         v-if="!agentStore.isAudioChatMode"
         v-model="agentStore.userMessageInput"
         ref="textInput"
+        rows="1"
         @input="autoResize"
         :class="[
-          'min-h-12 px-4 pt-4 rounded-xl w-full resize-none overflow-hidden text-lightInputText dark:text-darkInputText rounded-md bg-transparent text-sm bg-gray-50 dark:bg-gray-700 dark:border-gray-600 focus:outline-none',
+          'h-8 px-4 py-3 border-b rounded-xl rounded-b-none w-full resize-none overflow-hidden text-lightInputText dark:text-darkInputText rounded-md bg-transparent text-sm bg-gray-50 dark:bg-gray-700 dark:border-gray-600 focus:outline-none',
           { '!text-base': coreStore.isIos }
         ]"
-        :placeholder="agentStore.hasPendingToolApproval ? 'Approve or reject the pending action to continue' : agentStore.userMessagePlaceholder"
-        :disabled="agentStore.isMessageInputBlocked"
+        :placeholder="placeholderText"
         @keydown.enter.exact.prevent="sendMessage"
       />
+      <div class="flex items-center justify-between px-2 py-1">
       <div
         v-if="agentStore.availableModes.length > 1"
         ref="modeMenu"
-        class="absolute bottom-2 left-4"
+        class="relative"
       >
         <button
           aria-label="Select mode"
@@ -46,22 +49,30 @@
             :class="isModeMenuOpen ? '!rotate-180' : '!rotate-0'"
           />
         </button>
-
-        <div
-          v-if="isModeMenuOpen"
-          class="absolute bottom-full left-0 mb-2 min-w-40 overflow-hidden rounded-md border border-gray-200 bg-white shadow-lg dark:border-gray-600 dark:bg-gray-800"
-        >
-          <button
-            v-for="mode in agentStore.availableModes"
-            :key="mode.name"
-            class="block w-full px-3 py-2 text-left text-sm text-lightInputText transition-colors duration-150 hover:bg-gray-100 dark:text-darkInputText dark:hover:bg-gray-700"
-            :class="mode.name === agentStore.activeModeName ? 'bg-gray-100 dark:bg-gray-700' : ''"
-            type="button"
-            @click="selectMode(mode.name)"
+          <Transition
+            enter-active-class="transition ease-out duration-200"
+            enter-from-class="opacity-0 scale-95"
+            enter-to-class="opacity-100 scale-100"
+            leave-active-class="transition ease-in duration-150"
+            leave-from-class="opacity-100 scale-100"
+            leave-to-class="opacity-0 scale-95"
+          >
+          <div
+            v-if="isModeMenuOpen"
+            class="absolute bottom-full left-0 mb-2 min-w-40 overflow-hidden rounded-md border border-gray-200 bg-white shadow-lg dark:border-gray-600 dark:bg-gray-800"
           >
-            {{ mode.name }}
-          </button>
-        </div>
+            <button
+              v-for="mode in agentStore.availableModes"
+              :key="mode.name"
+              class="block w-full px-3 py-2 text-left text-sm text-lightInputText transition-colors duration-150 hover:bg-gray-100 dark:text-darkInputText dark:hover:bg-gray-700"
+              :class="mode.name === agentStore.activeModeName ? 'bg-gray-100 dark:bg-gray-700' : ''"
+              type="button"
+              @click="selectMode(mode.name)"
+            >
+              {{ mode.name }}
+            </button>
+          </div>
+        </Transition>
       </div>
       <MicrophoneButton 
         v-if="props.meta.hasAudioAdapter"   
@@ -69,32 +80,33 @@
       <template v-if="!agentStore.isAudioChatMode">
         <Button 
           v-if="!agentStore.isResponseInProgress"
-          class="absolute right-4 bottom-2 !p-0 h-9 w-9 transition-opacity duration-200"                    
+          class=" !p-0 h-7 w-7 transition-opacity duration-200"                    
           @click="sendMessage" 
-          :disabled="!agentStore.trimmedUserMessage || agentStore.isMessageInputBlocked"
+          :disabled="!agentStore.trimmedUserMessage"
         >
           <IconArrowUpOutline 
-            class="w-8 h-8 p-1
+            class="w-6 h-6
               text-white" 
           />
         </Button>
         <Button
           v-else
-          class="absolute right-4 bottom-2 !p-0 h-9 w-9"    
+          class="right-4 bottom-2 !p-0 h-7 w-7"    
           @click="stopCurrentRequest"                
         >
           <div
-            class="w-3 h-3 bg-white rounded-sm"
+            class="w-2.5 h-2.5 bg-white rounded-sm"
           />
         </Button>
       </template>
+      </div>
     </div>
   </div>
 </template>
 
 <script setup lang="ts">
 import { IconArrowUpOutline, IconAngleDownOutline } from '@iconify-prerendered/vue-flowbite';
-import { useTemplateRef, onMounted, ref, onUnmounted } from 'vue';
+import { useTemplateRef, onMounted, ref, onUnmounted, watch, computed } from 'vue';
 import { onClickOutside } from '@vueuse/core'
 import { useAgentStore } from './composables/useAgentStore';
 import { useAgentTransitions } from './composables/useAgentTransitions';
@@ -102,6 +114,8 @@ import { Button } from '@/afcl';
 import { useCoreStore } from '@/stores/core';
 import { remToPx } from './utils';
 import MicrophoneButton from './speech_recognition_frontend/MicrophoneButon.vue';
+import SteerQueue from './SteerQueue.vue';
+import SteerDebugPanel from './SteerDebugPanel.vue';
 
 const props = defineProps<{
   meta: {
@@ -124,6 +138,13 @@ const agentTransitions = useAgentTransitions();
 const coreStore = useCoreStore();
 const isModeMenuOpen = ref(false);
 
+const placeholderText = computed(() => {
+  if (agentStore.isTurnActive) {
+    return 'Queue a follow-up — send after, or steer it…';
+  }
+  return agentStore.userMessagePlaceholder;
+});
+
 onClickOutside(modeMenu as any, () => { isModeMenuOpen.value = false; });
 
 onMounted(async () => {
@@ -131,6 +152,11 @@ onMounted(async () => {
   agentStore.setCurrentGenerationModeFromLocalStorage();
   agentStore.regisrerTextInput(textInput.value);
   textInput.value?.focus();
+  autoResize();
+});
+
+watch(() => textInput.value?.value, () => {
+  autoResize();
 });
 
 function autoResize() {
@@ -161,7 +187,9 @@ function selectMode(modeName: string) {
 async function sendMessage() {
   if (agentStore.isAudioChatMode) return;
   isModeMenuOpen.value = false;
-  await agentStore.sendMessage();
+  // Routes to a steer (folded into the running turn) while generating, or a normal
+  // new-turn send when idle.
+  await agentStore.submitUserMessage();
   autoResize();
   props.conversationAreaRef?.handleSendMessage();
 }

package/dist/custom/SteerDebugPanel.vue

@@ -0,0 +1,45 @@
+<!--
+  TEMPORARY debug helper: enqueues a test steer message into the buffer WITHOUT sending
+  or steering it, so the SteerQueue enter/leave animation can be exercised without a live
+  generating turn. Remove before shipping.
+-->
+<template>
+  <div
+    class="fixed bottom-[400px] left-4 z-[9999] flex items-center gap-2 rounded-lg border border-dashed border-amber-400 bg-amber-50/95 px-2.5 py-2 shadow-lg backdrop-blur dark:border-amber-500 dark:bg-amber-950/95"
+  >
+    <span class="text-[10px] font-bold uppercase tracking-wider text-amber-600 dark:text-amber-400">
+      Steer&nbsp;debug
+    </span>
+    <input
+      v-model="debugText"
+      type="text"
+      placeholder="Test steer text…"
+      class="w-44 rounded-md border border-amber-300 bg-white px-2 py-1 text-xs text-gray-800 focus:outline-none focus:ring-1 focus:ring-amber-400 dark:border-amber-600 dark:bg-gray-800 dark:text-gray-100"
+      @keydown.enter.prevent="addTestSteer"
+    />
+    <button
+      type="button"
+      class="rounded-md bg-amber-500 px-2.5 py-1 text-xs font-semibold text-white transition-colors hover:bg-amber-600 active:bg-amber-700"
+      @click="addTestSteer"
+    >
+      Add steer
+    </button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue';
+import { useAgentStore } from './composables/useAgentStore';
+
+const agentStore = useAgentStore();
+const debugText = ref('');
+let counter = 0;
+
+function addTestSteer() {
+  counter += 1;
+  const text = debugText.value.trim() || `Test steer #${counter}`;
+  // enqueue() only pushes onto the client-side buffer — no /agent/steer, no send.
+  agentStore.enqueueSteerMessage(text);
+  debugText.value = '';
+}
+</script>

package/dist/custom/SteerQueue.vue

@@ -0,0 +1,54 @@
+<template>
+  <div
+    v-if="agentStore.steerQueue.length"
+    class="absolute bottom-full left-0 w-full mb-2 flex flex-col gap-1.5 px-2 z-20"
+  >
+    <TransitionGroup
+      appear
+      enter-active-class="transition ease-out duration-150"
+      enter-from-class="opacity-0 translate-y-1"
+      enter-to-class="opacity-100 translate-y-0"
+      leave-active-class="transition ease-in duration-100"
+      leave-from-class="opacity-100 translate-y-0"
+      leave-to-class="opacity-0 translate-y-1"
+    >
+      <div
+        v-for="item in agentStore.steerQueue"
+        :key="item.id"
+        class="flex items-center gap-2 rounded-lg border border-gray-200 bg-gray-50 px-3 py-1.5 shadow-sm dark:border-gray-600 dark:bg-gray-800"
+      >
+        <span
+          class="flex-1 min-w-0 truncate text-sm text-lightInputText dark:text-darkInputText"
+          :title="item.text"
+        >
+          {{ item.text }}
+        </span>
+        <span class="shrink-0 text-xs text-gray-400 dark:text-gray-500">
+          {{ $t('queued') }}
+        </span>
+        <button
+          type="button"
+          class="shrink-0 rounded-md px-2 py-1 text-xs font-medium text-lightPrimary transition-colors hover:bg-lightPrimary/10 dark:text-darkPrimary dark:hover:bg-darkPrimary/10"
+          :title="$t('Steer into the current response')"
+          @click="agentStore.steerQueuedMessage(item.id)"
+        >
+          {{ $t('Steer') }}
+        </button>
+        <button
+          type="button"
+          class="shrink-0 flex h-6 w-6 items-center justify-center rounded-md text-lg leading-none text-gray-400 transition-colors hover:bg-gray-200 hover:text-gray-600 dark:hover:bg-gray-700 dark:hover:text-gray-300"
+          :title="$t('Remove from queue')"
+          @click="agentStore.removeQueuedMessage(item.id)"
+        >
+          &times;
+        </button>
+      </div>
+    </TransitionGroup>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useAgentStore } from './composables/useAgentStore';
+
+const agentStore = useAgentStore();
+</script>

package/dist/custom/composables/agentStore/constants.ts

@@ -11,6 +11,7 @@ export const PLACEHOLDER_TYPING_DELAY_MS = 60;
 export const PLACEHOLDER_DELETING_DELAY_MS = 35;
 export const PLACEHOLDER_HOLD_DELAY_MS = 3000;
 export const PRE_SESSION_ID = 'pre-session';
+export const STEER_PERSIST_PREFIX = '__adminforth_steer__:';
 
 export enum RESERVED_SYSTEM_MESSAGE_CONTENT {
   START_AUDIO_CHAT = 'START_AUDIO_CHAT',

package/dist/custom/composables/agentStore/useAgentSessions.ts

@@ -2,7 +2,7 @@ import type { ComputedRef, Ref, ShallowRef } from 'vue';
 import { callAdminForthApi } from '@/utils';
 import type { Chat } from '../../chat';
 import type { IAgentSession, ISessionsListItem, IPart } from '../../types';
-import { PRE_SESSION_ID } from './constants';
+import { PRE_SESSION_ID, STEER_PERSIST_PREFIX } from './constants';
 import { i18nInstance } from '@/i18n';
 
 type AdminforthLike = {
@@ -50,14 +50,36 @@ export function createAgentSessionManager({
 
   function saveCurrentSessionInCache() {
     if (currentSession.value) {
-      currentSession.value.messages = currentChat.value?.messages.map((m: any) => ({
-        role: m.role,
-        text: m.parts.map((p: IPart) => p.type === 'text' ? p.text : '').join(''),
-      })) || [];
+      currentSession.value.messages = currentChat.value?.messages.map((m: any) => {
+        const text = m.parts.map((p: IPart) => p.type === 'text' ? p.text : '').join('');
+        if (m.role === 'user' && m.metadata?.steer) {
+          return { role: 'user', text: `${STEER_PERSIST_PREFIX}${text}` };
+        }
+        return { role: m.role, text };
+      }) || [];
       sessions.value[currentSession.value.sessionId] = currentSession.value;
     }
   }
 
+  function mapStoredMessage(m: any): any[] {
+    if (m.role === 'user' && typeof m.text === 'string' && m.text.includes(STEER_PERSIST_PREFIX)) {
+      const [prompt, ...steers] = m.text.split(STEER_PERSIST_PREFIX);
+      const mapped: any[] = [];
+      if (prompt) {
+        mapped.push({ role: 'user', parts: [{ type: 'text', text: prompt, state: 'done' }] });
+      }
+      for (const steer of steers) {
+        mapped.push({
+          role: 'user',
+          metadata: { steer: true },
+          parts: [{ type: 'text', text: steer, state: 'done' }],
+        });
+      }
+      return mapped;
+    }
+    return [{ role: m.role, parts: [{ type: 'text', text: m.text, state: 'done' }] }];
+  }
+
   async function fetchSession(sessionId: string) {
     try {
       const res = await callAdminForthApi({
@@ -85,14 +107,7 @@ export function createAgentSessionManager({
     currentSession.value = sessions.value[sessionId];
     setCurrentChat(sessionId);
     if (currentChat.value.messages.length === 0) {
-      currentChat.value.messages = currentSession.value?.messages.map((m: any) => ({
-        role: m.role,
-        parts:[{
-          type: 'text',
-          text: m.text,
-          state: 'done',
-        }]
-      }));
+      currentChat.value.messages = currentSession.value?.messages.flatMap(mapStoredMessage);
     }
   }
 
@@ -130,8 +145,10 @@ export function createAgentSessionManager({
     }
   }
 
-  async function sendMessage() {
-    const message = trimmedUserMessage.value;
+  async function sendMessage(explicitMessage?: string) {
+    // `explicitMessage` is used to drain a buffered (queued) message; without it we send
+    // whatever is currently typed in the input.
+    const message = (explicitMessage ?? trimmedUserMessage.value).trim();
     if (!message || isMessageInputBlocked.value) {
       return;
     }
@@ -147,7 +164,9 @@ export function createAgentSessionManager({
     currentChat.value?.sendMessage({
       text: message,
     });
-    userMessageInput.value = '';
+    if (explicitMessage === undefined) {
+      userMessageInput.value = '';
+    }
   }
 
   async function createPreSession() {

package/dist/custom/composables/agentStore/useAgentSteerQueue.ts

@@ -0,0 +1,114 @@
+import type { Ref, ShallowRef } from 'vue';
+import { ref } from 'vue';
+import { callAdminForthApi } from '@/utils';
+import type { Chat } from '../../chat';
+import type { IMessage } from '../../types';
+import { PRE_SESSION_ID } from './constants';
+
+export type QueuedMessage = {
+  id: string;
+  text: string;
+};
+
+type CreateAgentSteerQueueOptions = {
+  activeSessionId: Ref<string | null>;
+  currentChat: ShallowRef<Chat<any> | null | undefined>;
+  sendMessage: (text: string) => void | Promise<void>;
+};
+
+export function createAgentSteerQueue({
+  activeSessionId,
+  currentChat,
+  sendMessage,
+}: CreateAgentSteerQueueOptions) {
+  const queue = ref<QueuedMessage[]>([]);
+
+  function enqueue(text: string) {
+    const message = text.trim();
+    if (!message) {
+      return;
+    }
+    queue.value.push({ id: crypto.randomUUID(), text: message });
+  }
+
+  function removeQueuedMessage(id: string) {
+    queue.value = queue.value.filter((item: QueuedMessage) => item.id !== id);
+  }
+
+  function injectSteerMessage(text: string) {
+    const chat = currentChat.value;
+    if (!chat) {
+      return;
+    }
+    const steerMessage: IMessage = {
+      role: 'user',
+      metadata: { steer: true },
+      parts: [{ type: 'text', text, state: 'done' }],
+    };
+    const messages = chat.messages;
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.role === 'assistant') {
+      messages.splice(messages.length - 1, 0, steerMessage);
+    } else {
+      messages.push(steerMessage);
+    }
+  }
+
+  // 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.
+  async function persistSteerMessage(sessionId: string, text: string) {
+    try {
+      const res = await callAdminForthApi({
+        method: 'POST',
+        path: '/agent/append-steer-to-turn',
+        body: { sessionId, message: text },
+      });
+      if (res?.error) {
+        console.error('Error persisting steer message:', res.error);
+      }
+    } catch (error) {
+      console.error('Error persisting steer message', error);
+    }
+  }
+
+  async function steerQueuedMessage(id: string) {
+    const item = queue.value.find((candidate: QueuedMessage) => candidate.id === id);
+    const sessionId = activeSessionId.value;
+    if (!item || !sessionId || sessionId === PRE_SESSION_ID) {
+      return;
+    }
+    removeQueuedMessage(id);
+    injectSteerMessage(item.text);
+    void persistSteerMessage(sessionId, item.text);
+
+    try {
+      const res = await callAdminForthApi({
+        method: 'POST',
+        path: '/agent/steer',
+        body: { sessionId, message: item.text },
+      });
+      if (res?.error) {
+        console.error('Error steering agent:', res.error);
+      }
+    } catch (error) {
+      console.error('Error steering agent', error);
+    }
+  }
+
+  function flushNext() {
+    const next = queue.value.shift();
+    if (!next) {
+      return;
+    }
+    void sendMessage(next.text);
+  }
+
+  return {
+    queue,
+    enqueue,
+    removeQueuedMessage,
+    steerQueuedMessage,
+    flushNext,
+  };
+}

package/dist/custom/composables/useAgentStore.ts

@@ -18,6 +18,7 @@ import {
 import { createAgentChatManager } from './agentStore/useAgentChat';
 import { createAgentPlaceholderController } from './agentStore/useAgentPlaceholder';
 import { createAgentSessionManager } from './agentStore/useAgentSessions';
+import { createAgentSteerQueue } from './agentStore/useAgentSteerQueue';
 
 export const useAgentStore = defineStore('agent', () => {
   const agentTransitions = useAgentTransitions();
@@ -220,6 +221,42 @@ export const useAgentStore = defineStore('agent', () => {
     setCurrentChat,
   });
 
+  // "Turn active" = a request is in flight (submitted or streaming) or paused for HITL
+  // approval. Messages submitted during this window are buffered rather than sent.
+  const isTurnActive = computed(() => {
+    const status = (currentChat.value as any)?.status;
+    return status === 'submitted' || status === 'streaming' || hasPendingToolApproval.value;
+  });
+
+  const steerBuffer = createAgentSteerQueue({
+    activeSessionId,
+    currentChat,
+    sendMessage,
+  });
+
+  // Submitting while a turn is active buffers the message (it shows up in the steer
+  // queue, where the user can steer it or let it send); otherwise it sends right away.
+  function submitUserMessage() {
+    const message = trimmedUserMessage.value;
+    if (!message) {
+      return;
+    }
+    if (isTurnActive.value) {
+      steerBuffer.enqueue(message);
+      userMessageInput.value = '';
+      return;
+    }
+    return sendMessage();
+  }
+
+  // When the active turn finishes, drain the next buffered message as a normal send
+  // (one per turn, FIFO). Messages the user explicitly steered were already removed.
+  watch(isTurnActive, (active: boolean, wasActive: boolean) => {
+    if (wasActive && !active) {
+      steerBuffer.flushNext();
+    }
+  });
+
   watch(() => viewportWidth.value, (newWidth) => {
     if (isFullScreen.value) {
       setChatWidth(newWidth, false);
@@ -505,6 +542,14 @@ export const useAgentStore = defineStore('agent', () => {
     addDataToolCallMessage,
     openAgentPage,
     setCurrentChatStatus,
-    updateLastAgentMessage
+    updateLastAgentMessage,
+    //_________-Steer queue-_____________
+    submitUserMessage,
+    isTurnActive,
+    steerQueue: steerBuffer.queue,
+    steerQueuedMessage: steerBuffer.steerQueuedMessage,
+    removeQueuedMessage: steerBuffer.removeQueuedMessage,
+    enqueueSteerMessage: steerBuffer.enqueue,
+    //___________________________________
   }
 })

package/dist/custom/conversation_area/MessageRenderer.vue

@@ -1,5 +1,11 @@
 <template>
-  <ProcessingTimeline 
+  <div
+    v-if="message.role === 'user' && message.metadata?.steer"
+    class="self-end mr-4 mb-0.5 text-xs italic text-gray-400 dark:text-gray-500"
+  >
+    {{ $t('Steering instruction') }}
+  </div>
+  <ProcessingTimeline
     :message="message"
     :isLastMessageInChat="isLastMessageInChat"
   />

package/dist/custom/speech_recognition_frontend/AudioLines.vue

@@ -11,7 +11,7 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 
-const IDLE_LINE_HEIGHTS = [0.5, 1, 0.75, 0.5];
+const IDLE_LINE_HEIGHTS = [0.4, 0.8, 0.55, 0.4];
 const RECORDING_LINE_WEIGHTS = [0.45, 1, 0.75, 0.9, 0.55];
 const MIN_RECORDING_HEIGHT = 0.25;
 const MAX_RECORDING_DELTA = 0.9;

package/dist/custom/speech_recognition_frontend/MicrophoneButon.vue

@@ -1,7 +1,7 @@
 <template>
   <div
     v-show="!agentStore.isResponseInProgress || isAudioChatMode"
-    class="absolute bottom-2 flex items-center justify-center z-10 gap-4"
+    class="absolute bottom-1 flex items-center justify-center z-10 gap-4"
     :class="[!agentStore.isAudioChatMode ? 'right-16': agentStore.isMobile ? 'right-1/2 translate-x-1/2' : 'right-1/2 translate-x-1/2']"
   > 
     <button 
@@ -14,10 +14,10 @@
     </button>
     <button
       v-else 
-      class="h-9 bg-lightPrimary dark:bg-darkPrimary 
+      class="h-7 bg-lightPrimary dark:bg-darkPrimary 
         hover:opacity-90 rounded-full flex items-center justify-center
         transition-all duration-300 ease-in-out overflow-hidden"
-      :class="[isAudioChatMode ? 'w-32 px-2': 'w-9']" 
+      :class="[isAudioChatMode ? 'w-32 px-2': 'w-7']" 
       @click="toggleChatMode"
     >
       <div class="w-5 h-5 flex items-center justify-center">

package/dist/domain/agentEvents.d.ts

@@ -19,6 +19,10 @@ export type AgentEvent = {
     type: "interrupt";
     sessionId: string;
     interrupt: unknown;
+} | {
+    type: "steer-applied";
+    count: number;
+    ids: string[];
 } | {
     type: "open-page";
     targetPath: string;

package/dist/domain/steerBuffer.d.ts

@@ -0,0 +1,33 @@
+/** A single steering instruction the user sent while a turn was already running. */
+export type SteerMessage = {
+    id: string;
+    text: string;
+    /** Epoch ms the steer was enqueued; useful for ordering/debugging. */
+    at: number;
+};
+/**
+ * In-process, per-session buffer of steering instructions.
+ *
+ * While an agent turn is streaming (thinking / calling tools) the user may send
+ * one or more extra instructions ("steers"). Each is enqueued here by the
+ * `/agent/steer` endpoint and drained by the `beforeModel` steer middleware just
+ * before the next model call in the same running loop, so the model course-corrects
+ * mid-turn instead of the user having to abort and restart.
+ *
+ * The buffer is deliberately in-process: a steer only makes sense for a turn that
+ * is *currently running*, and that turn's SSE stream is held open on exactly one
+ * instance/process. In a multi-instance deployment the `/agent/steer` request must
+ * therefore reach the same instance running the turn (same constraint the in-memory
+ * HITL cache / MemorySaver already carry when no persistent checkpointer is set).
+ */
+export declare class SteerBuffer {
+    private readonly buffers;
+    /** Enqueue a steering instruction for a session. Returns the created entry. */
+    add(sessionId: string, text: string): SteerMessage;
+    /** Number of steers currently buffered for a session. */
+    size(sessionId: string): number;
+    /** Return every buffered steer for a session and remove them from the buffer. */
+    drain(sessionId: string): SteerMessage[];
+    /** Discard any buffered steers for a session (e.g. when its turn ends unconsumed). */
+    clear(sessionId: string): void;
+}

package/dist/domain/steerBuffer.js

@@ -0,0 +1,51 @@
+import { randomUUID } from "crypto";
+/**
+ * In-process, per-session buffer of steering instructions.
+ *
+ * While an agent turn is streaming (thinking / calling tools) the user may send
+ * one or more extra instructions ("steers"). Each is enqueued here by the
+ * `/agent/steer` endpoint and drained by the `beforeModel` steer middleware just
+ * before the next model call in the same running loop, so the model course-corrects
+ * mid-turn instead of the user having to abort and restart.
+ *
+ * The buffer is deliberately in-process: a steer only makes sense for a turn that
+ * is *currently running*, and that turn's SSE stream is held open on exactly one
+ * instance/process. In a multi-instance deployment the `/agent/steer` request must
+ * therefore reach the same instance running the turn (same constraint the in-memory
+ * HITL cache / MemorySaver already carry when no persistent checkpointer is set).
+ */
+export class SteerBuffer {
+    constructor() {
+        this.buffers = new Map();
+    }
+    /** Enqueue a steering instruction for a session. Returns the created entry. */
+    add(sessionId, text) {
+        const message = { id: randomUUID(), text, at: Date.now() };
+        const existing = this.buffers.get(sessionId);
+        if (existing) {
+            existing.push(message);
+        }
+        else {
+            this.buffers.set(sessionId, [message]);
+        }
+        return message;
+    }
+    /** Number of steers currently buffered for a session. */
+    size(sessionId) {
+        var _a, _b;
+        return (_b = (_a = this.buffers.get(sessionId)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }
+    /** Return every buffered steer for a session and remove them from the buffer. */
+    drain(sessionId) {
+        const messages = this.buffers.get(sessionId);
+        if (!messages || messages.length === 0) {
+            return [];
+        }
+        this.buffers.delete(sessionId);
+        return messages;
+    }
+    /** Discard any buffered steers for a session (e.g. when its turn ends unconsumed). */
+    clear(sessionId) {
+        this.buffers.delete(sessionId);
+    }
+}

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     private agentSystemPrompt;
     private checkpointer;
     private sessionStore;
+    private steerBuffer;
     private runTurnUseCase;
     private speechTurnService;
     private chatSurfaceService;

package/dist/index.js

@@ -23,6 +23,7 @@ import { AgentModelFactory } from "./llm/modelFactory.js";
 import { AgentRuntime } from "./llm/agentRuntime.js";
 import { SpeechTurnService } from "./transport/surfaces/speechTurnService.js";
 import { AgentToolProvider } from "./tools/agentToolProvider.js";
+import { SteerBuffer } from "./domain/steerBuffer.js";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     getCheckpointer() {
         if (this.checkpointer)
@@ -60,17 +61,20 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         this.checkpointer = null;
         this.options = options;
         this.sessionStore = new AgentSessionStore(() => this.adminforth, this.options);
+        this.steerBuffer = new SteerBuffer();
         const toolProvider = new AgentToolProvider(() => this.adminforth, this.getInternalAgentResourceIds.bind(this));
         const runtime = new AgentRuntime({
             name: `adminforth-agent-${this.pluginInstanceId}`,
             getAdminforth: () => this.adminforth,
             getCheckpointer: this.getCheckpointer.bind(this),
             toolProvider,
+            steerBuffer: this.steerBuffer,
         });
         const llm = new LangGraphLlm(runtime, new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000));
         this.runTurnUseCase = new RunTurnUseCase({
             llm,
             sessions: this.sessionStore,
+            steerBuffer: this.steerBuffer,
             modes: this.options.modes,
             getAdminforth: () => this.adminforth,
             getAgentSystemPrompt: this.getAgentSystemPrompt.bind(this),
@@ -146,10 +150,15 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             options: this.options,
             handleTurn: this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase),
             handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
+            steer: ({ sessionId, message }) => {
+                const { id } = this.steerBuffer.add(sessionId, message);
+                return { id, queued: this.steerBuffer.size(sessionId) };
+            },
             runAndPersistAgentResponse: this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase),
             getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
             createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),
             createSystemTurn: this.sessionStore.createSystemTurn.bind(this.sessionStore),
+            appendSteerToCurrentTurn: this.sessionStore.appendSteerToCurrentTurn.bind(this.sessionStore),
             handleChatSurfaceMessage: this.chatSurfaceService.handleMessage.bind(this.chatSurfaceService),
         };
         setupCoreEndpoints(endpointContext, server);

package/dist/llm/agentRuntime.d.ts

@@ -1,5 +1,6 @@
 import type { IAdminForth } from "adminforth";
 import type { BaseCheckpointSaver } from "@langchain/langgraph";
+import type { SteerBuffer } from "../domain/steerBuffer.js";
 import type { AgentToolProvider } from "../tools/agentToolProvider.js";
 import type { AgentRuntimeRunInput, AgentTurnModels } from "./agentModels.js";
 export type AgentRuntimeOptions = {
@@ -7,6 +8,8 @@ export type AgentRuntimeOptions = {
     getAdminforth: () => IAdminForth;
     getCheckpointer: () => BaseCheckpointSaver;
     toolProvider: AgentToolProvider;
+    /** Per-session buffer of mid-turn steering instructions drained by the steer middleware. */
+    steerBuffer: SteerBuffer;
 };
 export declare class AgentRuntime {
     private readonly options;

package/dist/llm/agentRuntime.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { createAgent, summarizationMiddleware, humanInTheLoopMiddleware } from "langchain";
 import { createApiBasedToolsMiddleware } from "./middleware/apiToolsMiddleware.js";
 import { createSequenceDebugMiddleware } from "./middleware/sequenceDebug.js";
+import { createSteerMiddleware } from "./middleware/steerMiddleware.js";
 import { createAgentLlmMetricsLogger } from "./agentModels.js";
 import { contextSchema, toLangchainAgentContext } from "./agentContext.js";
 function createHumanInTheLoopInterrupts(apiBasedTools) {
@@ -41,7 +42,9 @@ export class AgentRuntime {
                 interruptOn: createHumanInTheLoopInterrupts(apiBasedTools),
                 descriptionPrefix: "Tool execution pending approval",
             });
+            const steerMiddleware = createSteerMiddleware(this.options.steerBuffer);
             const middleware = [
+                steerMiddleware,
                 apiBasedToolsMiddleware,
                 hitlMiddleware,
                 ...((_a = input.models.modelMiddleware) !== null && _a !== void 0 ? _a : []),

package/dist/llm/middleware/steerMiddleware.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { AgentEventEmitter } from "../../domain/agentEvents.js";
+import type { SteerBuffer } from "../../domain/steerBuffer.js";
+/**
+ * `beforeModel` middleware that folds user "steering" instructions into a running
+ * turn. Before every model call in the agent loop it drains the per-session
+ * {@link SteerBuffer}; any buffered steers are appended to the conversation as
+ * user messages (so the model sees them on the very next call) and a
+ * `steer-applied` event is emitted on the turn's already-open SSE stream so the
+ * frontend knows the steer was actually consumed (not just received/queued).
+ *
+ * Placed first in the middleware array so the injected messages are present for
+ * every downstream `beforeModel` hook (e.g. summarization) and the model itself.
+ */
+export declare function createSteerMiddleware(steerBuffer: SteerBuffer): import("langchain").AgentMiddleware<undefined, z.ZodObject<{
+    sessionId: z.ZodString;
+    emit: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
+}, z.core.$strip>, {
+    sessionId: string;
+    emit?: AgentEventEmitter | undefined;
+}, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>;

package/dist/llm/middleware/steerMiddleware.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { HumanMessage } from "langchain";
+import { createMiddleware } from "langchain";
+import { z } from "zod";
+const steerContextSchema = z.object({
+    sessionId: z.string(),
+    emit: z.custom().optional(),
+});
+/**
+ * `beforeModel` middleware that folds user "steering" instructions into a running
+ * turn. Before every model call in the agent loop it drains the per-session
+ * {@link SteerBuffer}; any buffered steers are appended to the conversation as
+ * user messages (so the model sees them on the very next call) and a
+ * `steer-applied` event is emitted on the turn's already-open SSE stream so the
+ * frontend knows the steer was actually consumed (not just received/queued).
+ *
+ * Placed first in the middleware array so the injected messages are present for
+ * every downstream `beforeModel` hook (e.g. summarization) and the model itself.
+ */
+export function createSteerMiddleware(steerBuffer) {
+    return createMiddleware({
+        name: "SteerMiddleware",
+        contextSchema: steerContextSchema,
+        beforeModel(_state, runtime) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { sessionId, emit } = runtime.context;
+                const steers = steerBuffer.drain(sessionId);
+                if (steers.length === 0) {
+                    return;
+                }
+                void (emit === null || emit === void 0 ? void 0 : emit({
+                    type: "steer-applied",
+                    count: steers.length,
+                    ids: steers.map((steer) => steer.id),
+                }));
+                return {
+                    messages: steers.map((steer) => new HumanMessage(`[User steering — new instruction sent mid-turn, take it into account from now on]\n${steer.text}`)),
+                };
+            });
+        },
+    });
+}

package/dist/persistence/sessionStore.d.ts

@@ -3,12 +3,19 @@ import type { ChatSurfaceIncomingMessage } from "adminforth";
 import type { PreviousUserMessage } from "../domain/languageDetect.js";
 import type { PluginOptions } from "../types.js";
 export declare const AGENT_SYSTEM_TURN_PROMPT = "__adminforth_system_message__";
+export declare const STEER_PROMPT_MARKER = "__adminforth_steer__:";
 export declare class AgentSessionStore {
     private getAdminforth;
     private options;
     constructor(getAdminforth: () => IAdminForth, options: PluginOptions);
     createNewTurn(sessionId: string, prompt: string, response?: string): Promise<any>;
     createSystemTurn(sessionId: string, systemMessage: string): Promise<any>;
+    /**
+     * Append a mid-turn steer to the current (running) turn's prompt instead of creating a
+     * new record. Targets the latest non-system turn so a steer attaches to the real
+     * conversation turn, never an audio/system note.
+     */
+    appendSteerToCurrentTurn(sessionId: string, steerText: string): Promise<void>;
     getSessionTurns(sessionId: string): Promise<{
         prompt: any;
         response: any;

package/dist/persistence/sessionStore.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Filters, Sorts } from "adminforth";
 import { randomUUID } from "crypto";
 export const AGENT_SYSTEM_TURN_PROMPT = "__adminforth_system_message__";
+export const STEER_PROMPT_MARKER = "__adminforth_steer__:";
 export class AgentSessionStore {
     constructor(getAdminforth, options) {
         this.getAdminforth = getAdminforth;
@@ -41,6 +42,25 @@ export class AgentSessionStore {
             return newTurn.createdRecord[this.options.turnResource.idField];
         });
     }
+    /**
+     * Append a mid-turn steer to the current (running) turn's prompt instead of creating a
+     * new record. Targets the latest non-system turn so a steer attaches to the real
+     * conversation turn, never an audio/system note.
+     */
+    appendSteerToCurrentTurn(sessionId, steerText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.DESC(this.options.turnResource.createdAtField)]);
+            const turn = turns.find((candidate) => candidate[this.options.turnResource.promptField] !== AGENT_SYSTEM_TURN_PROMPT);
+            if (!turn) {
+                return;
+            }
+            const currentPrompt = (_a = turn[this.options.turnResource.promptField]) !== null && _a !== void 0 ? _a : "";
+            yield this.getAdminforth().resource(this.options.turnResource.resourceId).update(turn[this.options.turnResource.idField], {
+                [this.options.turnResource.promptField]: `${currentPrompt}${STEER_PROMPT_MARKER}${steerText}`,
+            });
+        });
+    }
     getSessionTurns(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.ASC(this.options.turnResource.createdAtField)]);

package/dist/transport/http/context.d.ts

@@ -10,12 +10,20 @@ export type AgentEndpointsContext = {
     options: PluginOptions;
     handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
     handleSpeechTurn(input: HandleSpeechTurnInput): Promise<RunAndPersistAgentResponseResult | null>;
+    steer(input: {
+        sessionId: string;
+        message: string;
+    }): {
+        id: string;
+        queued: number;
+    };
     runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
     getSessionTurns(sessionId: string): Promise<SessionTurn[]>;
     createNewTurn(sessionId: string, prompt: string, response?: string): Promise<string>;
     createSystemTurn(sessionId: string, systemMessage: string): Promise<string>;
+    appendSteerToCurrentTurn(sessionId: string, steerText: string): Promise<void>;
     handleChatSurfaceMessage(adapter: ChatSurfaceAdapter, incoming: ChatSurfaceIncomingMessage, sink: ChatSurfaceEventSink): Promise<void>;
 };
-export type CoreEndpointsContext = Pick<AgentEndpointsContext, "options" | "handleTurn" | "handleSpeechTurn">;
-export type SessionEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "getSessionTurns" | "createNewTurn" | "createSystemTurn">;
+export type CoreEndpointsContext = Pick<AgentEndpointsContext, "options" | "handleTurn" | "handleSpeechTurn" | "steer">;
+export type SessionEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "getSessionTurns" | "createNewTurn" | "createSystemTurn" | "appendSteerToCurrentTurn">;
 export type ChatSurfaceEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "handleChatSurfaceMessage">;

package/dist/transport/http/coreEndpoints.js

@@ -26,6 +26,10 @@ const agentApprovalBodySchema = z.object({
     sessionId: z.string(),
     decision: z.enum(["approve", "reject"]),
 }).strict();
+const agentSteerBodySchema = z.object({
+    sessionId: z.string(),
+    message: z.string().min(1),
+}).strict();
 // Sent as multipart/form-data (via multer), so every field arrives as a plain string on the wire.
 // `currentPage` is JSON.stringify'd by the client into a form field and must be parsed back into
 // an object. Zod -> JSON-Schema conversion cannot represent `.transform()` at all (it throws), so
@@ -122,6 +126,22 @@ export function setupCoreEndpoints(ctx, server) {
             return null;
         })
     });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/steer`,
+        request_schema: agentSteerBodySchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body }) {
+            const data = body;
+            // Fire-and-forget: the steer is buffered and folded into the running turn by the
+            // beforeModel steer middleware, which signals `data-steer-applied` on that turn's
+            // SSE stream once consumed. This endpoint only confirms it was received/queued.
+            const { id, queued } = ctx.steer({
+                sessionId: data.sessionId,
+                message: data.message,
+            });
+            return { ok: true, id, queued };
+        })
+    });
     server.endpoint({
         method: 'POST',
         path: `/agent/speech-response`,

package/dist/transport/http/sessionEndpoints.js

@@ -15,6 +15,10 @@ const addSystemMessageBodySchema = z.object({
     sessionId: z.string(),
     systemMessage: z.string(),
 }).strict();
+const appendSteerBodySchema = z.object({
+    sessionId: z.string(),
+    message: z.string().min(1),
+}).strict();
 const getSessionsBodySchema = z.object({
     limit: z.number().int().min(1).max(100).optional(),
 }).strict();
@@ -175,4 +179,29 @@ export function setupSessionEndpoints(ctx, server) {
             };
         })
     });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/append-steer-to-turn`,
+        request_schema: appendSteerBodySchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            const data = body;
+            const session = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).get([Filters.EQ(ctx.options.sessionResource.idField, data.sessionId)]);
+            if (!session) {
+                response.setStatus(404, 'Session not found');
+                return {
+                    error: 'Session not found'
+                };
+            }
+            if (session[ctx.options.sessionResource.askerIdField] !== adminUser.pk) {
+                response.setStatus(403, 'Unauthorized');
+                return {
+                    error: 'Unauthorized'
+                };
+            }
+            yield ctx.appendSteerToCurrentTurn(data.sessionId, data.message);
+            return {
+                ok: true
+            };
+        })
+    });
 }

package/dist/transport/sse/sseWriter.d.ts

@@ -17,9 +17,9 @@ type AgentEventStreamOptions = {
  *
  * - `vercelAiUiMessageStream: true` (used by `/agent/response` and `/agent/approval`):
  *   the Vercel AI SDK message-stream v1 format (`start`, `text-start`/`text-delta`/
- *   `text-end`, `reasoning-*`, `data-*` parts, `error` with `errorText`, `finish`,
- *   `[DONE]`). Consumed by `DefaultChatTransport` and the manual approval parser in
- *   `custom/composables/agentStore/useAgentChat.ts`.
+ *   `text-end`, `reasoning-*`, `data-*` parts including `data-steer-applied`,
+ *   `error` with `errorText`, `finish`, `[DONE]`). Consumed by `DefaultChatTransport`
+ *   and the manual approval parser in `custom/composables/agentStore/useAgentChat.ts`.
  * - default (used by `/agent/speech-response`): bare event names
  *   (`transcript`, `speech-response`, `audio-start`/`audio-delta`/`audio-done`,
  *   `open-page`, `error`) plus the Vercel-shaped `data-tool-call`. Consumed by

package/dist/transport/sse/sseWriter.js

@@ -98,6 +98,15 @@ function createAgentEventStream(res, options = {}) {
                 },
             });
         },
+        steerApplied(count, ids) {
+            stream.send({
+                type: isAiUiMessageStream ? "data-steer-applied" : "steer-applied",
+                data: {
+                    count,
+                    ids,
+                },
+            });
+        },
         openPage(targetPath) {
             stream.send({
                 type: isAiUiMessageStream ? "data-open-page" : "open-page",
@@ -192,9 +201,9 @@ function createAgentEventStream(res, options = {}) {
  *
  * - `vercelAiUiMessageStream: true` (used by `/agent/response` and `/agent/approval`):
  *   the Vercel AI SDK message-stream v1 format (`start`, `text-start`/`text-delta`/
- *   `text-end`, `reasoning-*`, `data-*` parts, `error` with `errorText`, `finish`,
- *   `[DONE]`). Consumed by `DefaultChatTransport` and the manual approval parser in
- *   `custom/composables/agentStore/useAgentChat.ts`.
+ *   `text-end`, `reasoning-*`, `data-*` parts including `data-steer-applied`,
+ *   `error` with `errorText`, `finish`, `[DONE]`). Consumed by `DefaultChatTransport`
+ *   and the manual approval parser in `custom/composables/agentStore/useAgentChat.ts`.
  * - default (used by `/agent/speech-response`): bare event names
  *   (`transcript`, `speech-response`, `audio-start`/`audio-delta`/`audio-done`,
  *   `open-page`, `error`) plus the Vercel-shaped `data-tool-call`. Consumed by
@@ -222,6 +231,9 @@ export function createSseEventEmitter(res, options = {}) {
             case "interrupt":
                 stream.interrupt(event.sessionId, event.interrupt);
                 break;
+            case "steer-applied":
+                stream.steerApplied(event.count, event.ids);
+                break;
             case "open-page":
                 stream.openPage(event.targetPath);
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",