@adminforth/agent 2.2.5 → 2.3.0

package/dist/application/ports.d.ts

@@ -32,6 +32,7 @@ export type LlmStreamInput = {
     };
     context: AgentTurnContext;
     observability: AgentTurnObservability;
+    branchFromCheckpointId?: string;
 };
 /**
  * The boundary between the application layer and the concrete LLM runtime
@@ -63,4 +64,21 @@ export interface LlmPort {
         completionAdapter: AgentModeCompletionAdapter;
         sessionId: string;
     }): Promise<PendingInterrupt[]>;
+    /**
+     * Return the session thread's latest (tip) checkpoint id, or null when the thread
+     * has no persisted state. Recorded on each turn so message editing can fork from
+     * the previous turn's checkpoint.
+     */
+    getLatestCheckpointId(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        sessionId: string;
+    }): Promise<string | null>;
+    /**
+     * Drop the entire LangGraph checkpoint thread for a session. Used when editing the
+     * first message, where there is no earlier checkpoint to fork from.
+     */
+    resetThreadCheckpoints(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        sessionId: string;
+    }): Promise<void>;
 }

package/dist/application/runTurnUseCase.d.ts

@@ -3,7 +3,7 @@ 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";
+import type { DebugSink, HandleTurnInput, HandleEditTurnInput, PendingInterrupt, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "../domain/turnTypes.js";
 /**
  * Build the provider-agnostic resume payload for a human-in-the-loop turn.
  * Exported for unit testing; the LLM port wraps it into a LangGraph Command.
@@ -41,6 +41,13 @@ export type RunTurnUseCaseDeps = {
     getAgentSystemPrompt: () => Promise<string>;
     /** True when a persistent checkpointer is configured (not the in-memory MemorySaver). */
     hasPersistentCheckpointer: boolean;
+    /**
+     * True when `turnResource.checkpointIdField` is configured — the tip checkpoint id
+     * is then recorded per turn, enabling message editing / branching.
+     */
+    turnCheckpointsEnabled: boolean;
+    /** Resource config used for the edit ownership check + turn lookups. */
+    sessionResource: PluginOptions["sessionResource"];
     /** Factory for the per-turn debug sink; the concrete impl lives in the llm layer. */
     createDebugSink: () => DebugSink;
 };
@@ -62,10 +69,19 @@ export declare class RunTurnUseCase {
      * MemorySaver the in-process cache is authoritative (single process, cannot be stale).
      */
     private resolvePendingInterrupts;
+    /** Verify the session exists and belongs to the requesting admin user. */
+    private assertSessionOwnership;
+    /**
+     * Prepare an edit/branch turn: validate ownership, resolve the fork checkpoint from
+     * the previous turn, truncate the conversation after the edited turn, and reuse the
+     * edited turn's id for the regenerated response.
+     */
+    private prepareEditTurn;
     private prepareTurn;
     private buildMessages;
     private handleInterrupt;
     private runAgentTurn;
     runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
     handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
+    handleEditTurn(input: HandleEditTurnInput): Promise<RunAndPersistAgentResponseResult>;
 }

package/dist/application/runTurnUseCase.js

@@ -14,7 +14,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-import { logger } from "adminforth";
+import { logger, Filters } from "adminforth";
 import { randomUUID } from "crypto";
 import { VegaLiteStreamBuffer } from "../domain/vegaLiteStreamBuffer.js";
 import { buildAgentTurnSystemPrompt } from "../domain/systemPrompt.js";
@@ -121,12 +121,88 @@ export class RunTurnUseCase {
             return (_a = this.pendingInterrupts.get(sessionId)) !== null && _a !== void 0 ? _a : [];
         });
     }
+    /** Verify the session exists and belongs to the requesting admin user. */
+    assertSessionOwnership(sessionId, adminUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const s = this.deps.sessionResource;
+            const session = yield this.deps.getAdminforth().resource(s.resourceId).get([Filters.EQ(s.idField, sessionId)]);
+            if (!session) {
+                throw new Error(`Session "${sessionId}" not found.`);
+            }
+            if (session[s.askerIdField] !== adminUser.pk) {
+                throw new Error(`Session "${sessionId}" does not belong to the current user.`);
+            }
+        });
+    }
+    /**
+     * Prepare an edit/branch turn: validate ownership, resolve the fork checkpoint from
+     * the previous turn, truncate the conversation after the edited turn, and reuse the
+     * edited turn's id for the regenerated response.
+     */
+    prepareEditTurn(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sequenceDebugSink = this.deps.createDebugSink();
+            const mode = this.resolveMode(input.modeName);
+            const editTurnId = input.editTurnId;
+            if (!this.deps.turnCheckpointsEnabled) {
+                throw new Error("Edit/fork requires checkpointIdField to be configured on turnResource.");
+            }
+            yield this.assertSessionOwnership(input.sessionId, input.adminUser);
+            const agentTurns = yield this.deps.sessions.getAgentTurns(input.sessionId);
+            const targetIndex = agentTurns.findIndex((turn) => turn.id === editTurnId);
+            if (targetIndex === -1) {
+                throw new Error(`Turn "${editTurnId}" not found in session "${input.sessionId}".`);
+            }
+            const previous = agentTurns[targetIndex - 1];
+            let branchFromCheckpointId;
+            if (previous) {
+                if (!previous.checkpointId) {
+                    throw new Error(`Cannot edit this message: the previous turn has no stored checkpoint to branch from.`);
+                }
+                branchFromCheckpointId = previous.checkpointId;
+            }
+            else {
+                // No earlier turn to fork from — drop the whole thread and start fresh.
+                yield this.deps.llm.resetThreadCheckpoints({
+                    completionAdapter: mode.completionAdapter,
+                    sessionId: input.sessionId,
+                });
+            }
+            // Language-detection context: the kept user messages just before the edited turn.
+            const previousUserMessages = agentTurns
+                .slice(Math.max(0, targetIndex - 2), targetIndex)
+                .map((turn) => ({ text: turn.prompt }));
+            // Editing supersedes any in-flight turn state for this session.
+            this.deps.steerBuffer.clear(input.sessionId);
+            this.pendingInterrupts.delete(input.sessionId);
+            // Apply the edit + truncate (deletes later turns first, then rewrites the edited turn).
+            yield this.deps.sessions.editTurnAndTruncateAfter({
+                sessionId: input.sessionId,
+                turnId: editTurnId,
+                newPrompt: input.prompt,
+            });
+            yield this.deps.sessions.touchSession(input.sessionId);
+            return {
+                prompt: input.prompt,
+                sessionId: input.sessionId,
+                turnId: editTurnId,
+                previousUserMessages,
+                mode,
+                context: this.buildContext(input, editTurnId),
+                observability: { emit: input.emit, sequenceDebugSink },
+                branchFromCheckpointId,
+            };
+        });
+    }
     prepareTurn(input) {
         return __awaiter(this, void 0, void 0, function* () {
             const sequenceDebugSink = this.deps.createDebugSink();
             const mode = this.resolveMode(input.modeName);
             const approvalDecision = getApprovalDecision(input);
             const shouldResume = Boolean(approvalDecision);
+            if (input.editTurnId && !shouldResume) {
+                return this.prepareEditTurn(input);
+            }
             let turnId;
             let previousUserMessages = [];
             let initialResponse;
@@ -228,6 +304,7 @@ export class RunTurnUseCase {
                 input: streamInput,
                 context: prepared.context,
                 observability: prepared.observability,
+                branchFromCheckpointId: prepared.branchFromCheckpointId,
             });
             const { emit } = prepared.observability;
             const abortSignal = prepared.context.abortSignal;
@@ -285,9 +362,14 @@ export class RunTurnUseCase {
     }
     runAndPersistAgentResponse(input) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const prepared = yield this.prepareTurn(input);
-            let fullResponse = (_a = prepared.initialResponse) !== null && _a !== void 0 ? _a : "";
+            yield ((_b = (_a = prepared.observability).emit) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                type: "turn-persisted",
+                sessionId: prepared.sessionId,
+                turnId: prepared.turnId,
+            }));
+            let fullResponse = (_c = prepared.initialResponse) !== null && _c !== void 0 ? _c : "";
             let aborted = false;
             let failed = false;
             try {
@@ -295,7 +377,7 @@ export class RunTurnUseCase {
                 fullResponse += agentResponse.text;
             }
             catch (error) {
-                if (((_b = input.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) || isAbortError(error)) {
+                if (((_d = input.abortSignal) === null || _d === void 0 ? void 0 : _d.aborted) || isAbortError(error)) {
                     aborted = true;
                     logger.info(input.abortLogMessage);
                 }
@@ -305,11 +387,28 @@ export class RunTurnUseCase {
                     logger.error(`${input.failureLogMessage}:\n${fullResponse}`);
                 }
             }
+            // Record the turn's tip checkpoint id ONLY on success, so message editing can
+            // fork from it. On abort/failure leave the previous value untouched (undefined =
+            // don't overwrite). Never let a checkpoint read break response persistence.
+            let checkpointId;
+            if (!aborted && !failed && this.deps.turnCheckpointsEnabled) {
+                try {
+                    checkpointId = yield this.deps.llm.getLatestCheckpointId({
+                        completionAdapter: prepared.mode.completionAdapter,
+                        sessionId: prepared.sessionId,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`Failed to read latest checkpoint id for turn "${prepared.turnId}": ${getErrorMessage(error)}`);
+                    checkpointId = undefined;
+                }
+            }
             prepared.observability.sequenceDebugSink.flush();
             yield this.deps.sessions.saveTurnResponse({
                 turnId: prepared.turnId,
                 responseText: fullResponse,
                 debugHistory: prepared.observability.sequenceDebugSink.getHistory(),
+                checkpointId,
             });
             return {
                 text: fullResponse,
@@ -361,4 +460,46 @@ export class RunTurnUseCase {
             return agentResponse;
         });
     }
+    handleEditTurn(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield input.emit({
+                type: "turn-started",
+                messageId: randomUUID(),
+            });
+            const agentResponse = yield this.runAndPersistAgentResponse({
+                prompt: input.prompt,
+                sessionId: input.sessionId,
+                modeName: input.modeName,
+                userTimeZone: input.userTimeZone,
+                currentPage: input.currentPage,
+                chatSurface: input.chatSurface,
+                adminPublicOrigin: input.adminPublicOrigin,
+                editTurnId: input.turnId,
+                abortSignal: input.abortSignal,
+                adminUser: input.adminUser,
+                emit: input.emit,
+                failureLogMessage: (_a = input.failureLogMessage) !== null && _a !== void 0 ? _a : "Agent message edit failed",
+                abortLogMessage: (_b = input.abortLogMessage) !== null && _b !== void 0 ? _b : "Agent message edit aborted",
+            });
+            if (agentResponse.failed) {
+                yield input.emit({
+                    type: "error",
+                    error: agentResponse.text,
+                });
+            }
+            else if (!agentResponse.aborted) {
+                yield input.emit({
+                    type: "response",
+                    text: agentResponse.text,
+                    sessionId: input.sessionId,
+                    turnId: agentResponse.turnId,
+                });
+            }
+            yield input.emit({
+                type: "finish",
+            });
+            return agentResponse;
+        });
+    }
 }

package/dist/custom/ChatFooter.vue

@@ -59,7 +59,7 @@
           >
           <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"
+            class="absolute z-20 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"
@@ -75,29 +75,52 @@
         </Transition>
       </div>
       <MicrophoneButton 
-        v-if="props.meta.hasAudioAdapter"   
+        v-if="props.meta.hasAudioAdapter"
+        v-show="!agentStore.isEditingMessage"   
       />
       <template v-if="!agentStore.isAudioChatMode">
-        <Button 
-          v-if="!agentStore.isResponseInProgress"
-          class=" !p-0 h-7 w-7 transition-opacity duration-200"                    
-          @click="sendMessage" 
-          :disabled="!agentStore.trimmedUserMessage"
-        >
-          <IconArrowUpOutline 
-            class="w-6 h-6
-              text-white" 
-          />
-        </Button>
-        <Button
-          v-else
-          class="right-4 bottom-2 !p-0 h-7 w-7"    
-          @click="stopCurrentRequest"                
-        >
-          <div
-            class="w-2.5 h-2.5 bg-white rounded-sm"
-          />
-        </Button>
+        <template v-if="agentStore.isEditingMessage">
+          <div class="flex items-center gap-3">
+            <Button
+              variant="secondary"
+              class="!p-0 h-7 w-7 mr-1 bg-red-600 text-white hover:bg-red-700 dark:bg-red-700 dark:hover:bg-red-800"
+              title="Cancel edit"
+              @click="cancelEdit"
+            >
+              <IconCloseOutline class="w-5 h-5" />
+            </Button>
+            <Button
+              class="!p-0 h-7 w-7"
+              title="Send edited message"
+              @click="sendMessage"
+              :disabled="!agentStore.trimmedUserMessage"
+            >
+              <IconCheckOutline class="w-6 h-6 text-white" />
+            </Button>
+          </div>
+        </template>
+        <template v-else>
+          <Button
+            v-if="!agentStore.isResponseInProgress"
+            class=" !p-0 h-7 w-7 transition-opacity duration-200"
+            @click="sendMessage"
+            :disabled="!agentStore.trimmedUserMessage"
+          >
+            <IconArrowUpOutline
+              class="w-6 h-6
+                text-white"
+            />
+          </Button>
+          <Button
+            v-else
+            class="right-4 bottom-2 !p-0 h-7 w-7"
+            @click="stopCurrentRequest"
+          >
+            <div
+              class="w-2.5 h-2.5 bg-white rounded-sm"
+            />
+          </Button>
+        </template>
       </template>
       </div>
     </div>
@@ -105,7 +128,7 @@
 </template>
 
 <script setup lang="ts">
-import { IconArrowUpOutline, IconAngleDownOutline } from '@iconify-prerendered/vue-flowbite';
+import { IconArrowUpOutline, IconAngleDownOutline, IconCloseOutline, IconCheckOutline } from '@iconify-prerendered/vue-flowbite';
 import { useTemplateRef, onMounted, ref, onUnmounted, watch, computed } from 'vue';
 import { onClickOutside } from '@vueuse/core'
 import { useAgentStore } from './composables/useAgentStore';
@@ -126,6 +149,7 @@ const props = defineProps<{
     defaultModeName: string | null;
     stickByDefault: boolean;
     hasAudioAdapter: boolean;
+    editingEnabled: boolean;
   }
   adminUser: any
   conversationAreaRef: any
@@ -150,6 +174,7 @@ onClickOutside(modeMenu as any, () => { isModeMenuOpen.value = false; });
 onMounted(async () => {
   agentStore.setAvailableModes(props.meta.modes, props.meta.defaultModeName);
   agentStore.setCurrentGenerationModeFromLocalStorage();
+  agentStore.setEditingEnabled(props.meta.editingEnabled);
   agentStore.regisrerTextInput(textInput.value);
   textInput.value?.focus();
   autoResize();
@@ -187,6 +212,14 @@ function selectMode(modeName: string) {
 async function sendMessage() {
   if (agentStore.isAudioChatMode) return;
   isModeMenuOpen.value = false;
+  // While editing a message, the same send action commits the edit (regenerating
+  // from that turn) instead of starting/steering a turn.
+  if (agentStore.isEditingMessage) {
+    await agentStore.submitEditMessage();
+    autoResize();
+    props.conversationAreaRef?.handleSendMessage();
+    return;
+  }
   // Routes to a steer (folded into the running turn) while generating, or a normal
   // new-turn send when idle.
   await agentStore.submitUserMessage();
@@ -194,6 +227,11 @@ async function sendMessage() {
   props.conversationAreaRef?.handleSendMessage();
 }
 
+function cancelEdit() {
+  agentStore.cancelEditMessage();
+  autoResize();
+}
+
 function stopCurrentRequest() {
   agentStore.abortCurrentChatRequestAndAddSystemMessage();
 }

package/dist/custom/ChatSurface.vue

@@ -78,6 +78,7 @@ const props = defineProps<{
     defaultModeName: string | null;
     stickByDefault: boolean;
     hasAudioAdapter: boolean;
+    editingEnabled: boolean;
   }
   adminUser: any
 }>();

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

@@ -1,5 +1,5 @@
 import { DefaultChatTransport } from 'ai';
-import { shallowRef, type Ref } from 'vue';
+import { ref, shallowRef, watch, type Ref } from 'vue';
 import { Chat } from '../../chat';
 import { getCurrentPageContext } from './pageContext';
 // const { DefaultChatTransport } = await import('ai');
@@ -25,6 +25,7 @@ export function createAgentChatManager({
 }: CreateAgentChatManagerOptions) {
   const chats = new Map<string, Chat<any>>();
   const currentChat = shallowRef<Chat<any> | null>();
+  const editingTurnId = ref<string | null>(null);
   const agentApiBase = `${(import.meta as AgentImportMeta).env.VITE_ADMINFORTH_PUBLIC_PATH || ''}/adminapi/v1/agent`;
 
   function replaceLastMessage(message: any) {
@@ -89,6 +90,26 @@ export function createAgentChatManager({
     replaceLastMessage(assistantMessage);
   }
 
+  // Stamp the just-finished turn's id onto its prompt message so it becomes editable
+  // without a session reload. The prompt is the last user message that isn't a
+  // mid-turn steer.
+  function tagCurrentTurnPrompt(turnId: string) {
+    const messages = currentChat.value?.messages;
+    if (!messages) {
+      return;
+    }
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i];
+      if (message.role === 'user' && !message.metadata?.steer) {
+        messages.splice(i, 1, {
+          ...message,
+          metadata: { ...(message.metadata ?? {}), turnId },
+        });
+        return;
+      }
+    }
+  }
+
   function handleRealtimeChatData(dataPart: any) {
     if (dataPart?.type === 'data-open-page' && typeof dataPart.data?.targetPath === 'string') {
       onOpenPage(dataPart.data.targetPath);
@@ -97,6 +118,16 @@ export function createAgentChatManager({
 
     if (dataPart?.type === 'data-interrupt' && typeof dataPart.data?.sessionId === 'string') {
       onToolApprovalRequest(dataPart.data.sessionId, dataPart.data.interrupt);
+      return;
+    }
+
+    // `data-turn-persisted` arrives at turn start, `data-response` at turn end — either
+    // way, stamp the prompt with its turn id so it can be edited.
+    if (
+      (dataPart?.type === 'data-turn-persisted' || dataPart?.type === 'data-response')
+      && typeof dataPart.data?.turnId === 'string'
+    ) {
+      tagCurrentTurnPrompt(dataPart.data.turnId);
     }
   }
 
@@ -128,6 +159,14 @@ export function createAgentChatManager({
 
     if (dataPart?.type === 'data-interrupt' && typeof dataPart.data?.sessionId === 'string') {
       onToolApprovalRequest(dataPart.data.sessionId, dataPart.data.interrupt);
+      return;
+    }
+
+    if (
+      (dataPart?.type === 'data-turn-persisted' || dataPart?.type === 'data-response')
+      && typeof dataPart.data?.turnId === 'string'
+    ) {
+      tagCurrentTurnPrompt(dataPart.data.turnId);
     }
   }
 
@@ -178,7 +217,11 @@ export function createAgentChatManager({
           credentials: 'include',
           prepareSendMessagesRequest({ messages }: any) {
             const message = lastMessage.value;
-            const body = {
+            const headers = {
+              Accept: 'text/event-stream',
+              'x-vercel-ai-ui-message-stream': 'v1',
+            };
+            const body: Record<string, any> = {
               message,
               sessionId,
               timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
@@ -186,12 +229,20 @@ export function createAgentChatManager({
               currentPage: getCurrentPageContext(),
             };
 
+            // Editing an existing message branches from its turn: hit /edit, which
+            // truncates every turn after `turnId` and regenerates from that point.
+            if (editingTurnId.value) {
+              body.turnId = editingTurnId.value;
+              return {
+                api: `${agentApiBase}/edit`,
+                headers,
+                body,
+              };
+            }
+
             return {
-              headers: {
-                Accept: 'text/event-stream',
-                'x-vercel-ai-ui-message-stream': 'v1',
-              },
-              body
+              headers,
+              body,
             };
           }
         }),
@@ -210,6 +261,69 @@ export function createAgentChatManager({
     currentChat.value?.stop();
   }
 
+  function isChatBusy() {
+    const status = (currentChat.value as any)?.status;
+    return status === 'streaming' || status === 'submitted';
+  }
+
+  async function stopActiveTurnAndWaitForIdle() {
+    const chat = currentChat.value;
+    if (!chat || !isChatBusy()) {
+      return;
+    }
+    await chat.stop();
+    if (!isChatBusy()) {
+      return;
+    }
+    await new Promise<void>((resolve) => {
+      let settled = false;
+      let stopWatch = () => {};
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        stopWatch();
+        resolve();
+      };
+      // Safety valve so a stuck status can never hang the edit indefinitely.
+      const timer = setTimeout(finish, 3000);
+      stopWatch = watch(
+        () => (currentChat.value as any)?.status,
+        () => {
+          if (!isChatBusy()) {
+            finish();
+          }
+        },
+      );
+    });
+  }
+
+  // Replace the target user message in place and regenerate from it. The SDK's
+  // `sendMessage({ messageId })` truncates every message after the replaced one
+  // (mirroring the server-side truncate), and `editingTurnId` routes the request
+  // to /edit for the matching turn. If a turn is still generating it is stopped
+  // first so the edit supersedes it.
+  async function sendEditMessage({ messageId, turnId, text }: { messageId: string; turnId: string; text: string; }) {
+    const chat = currentChat.value;
+    if (!chat) {
+      return;
+    }
+    const currentMessage = chat.messages.find((m: any) => m.id === messageId);
+    if (!currentMessage || currentMessage.parts[0].text.trim() === text.trim()) {
+      return;
+    }
+    await stopActiveTurnAndWaitForIdle();
+    editingTurnId.value = turnId;
+    lastMessage.value = text;
+    try {
+      await chat.sendMessage({ text, messageId, metadata: { turnId } });
+    } finally {
+      editingTurnId.value = null;
+    }
+  }
+
   async function submitToolApproval(sessionId: string, decision: 'approve' | 'reject') {
     const response = await fetch(`${agentApiBase}/approval`, {
       method: 'POST',
@@ -237,5 +351,6 @@ export function createAgentChatManager({
     setCurrentChat,
     abortCurrentChatRequest,
     submitToolApproval,
+    sendEditMessage,
   };
 }

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

@@ -52,32 +52,35 @@ export function createAgentSessionManager({
     if (currentSession.value) {
       currentSession.value.messages = currentChat.value?.messages.map((m: any) => {
         const text = m.parts.map((p: IPart) => p.type === 'text' ? p.text : '').join('');
+        const turnId = m.metadata?.turnId;
         if (m.role === 'user' && m.metadata?.steer) {
-          return { role: 'user', text: `${STEER_PERSIST_PREFIX}${text}` };
+          return { role: 'user', text: `${STEER_PERSIST_PREFIX}${text}`, turnId };
         }
-        return { role: m.role, text };
+        return { role: m.role, text, turnId };
       }) || [];
       sessions.value[currentSession.value.sessionId] = currentSession.value;
     }
   }
 
   function mapStoredMessage(m: any): any[] {
+    const turnId = m.turnId;
     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' }] });
+        mapped.push({ id: crypto.randomUUID(), role: 'user', metadata: { turnId }, parts: [{ type: 'text', text: prompt, state: 'done' }] });
       }
       for (const steer of steers) {
         mapped.push({
+          id: crypto.randomUUID(),
           role: 'user',
-          metadata: { steer: true },
+          metadata: { turnId, steer: true },
           parts: [{ type: 'text', text: steer, state: 'done' }],
         });
       }
       return mapped;
     }
-    return [{ role: m.role, parts: [{ type: 'text', text: m.text, state: 'done' }] }];
+    return [{ id: crypto.randomUUID(), role: m.role, metadata: { turnId }, parts: [{ type: 'text', text: m.text, state: 'done' }] }];
   }
 
   async function fetchSession(sessionId: string) {

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

@@ -97,7 +97,6 @@ export function createAgentSteerQueue({
         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: [] };
@@ -175,11 +174,16 @@ export function createAgentSteerQueue({
     void sendMessage(next.text);
   }
 
+  function clear() {
+    queue.value = [];
+  }
+
   return {
     queue,
     enqueue,
     removeQueuedMessage,
     steerQueuedMessage,
     flushNext,
+    clear,
   };
 }