@adminforth/agent 2.2.4 → 2.3.0

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

package/dist/custom/composables/useAgentStore.ts

@@ -34,6 +34,14 @@ export const useAgentStore = defineStore('agent', () => {
   const textInput = ref<HTMLTextAreaElement | null>(null);
   const userMessageInput = ref();
   const trimmedUserMessage = computed(() => userMessageInput.value ? userMessageInput.value.trim() : '');
+  // Message-edit state. `editingEnabled` mirrors the server capability (checkpointer +
+  // turn checkpoints). While a message is being edited its id/turnId are held here and
+  // the user's in-progress input is stashed in `savedUserInput` so it can be restored.
+  const editingEnabled = ref(false);
+  const editingMessageId = ref<string | null>(null);
+  const editingMessageTurnId = ref<string | null>(null);
+  const savedUserInput = ref('');
+  const isEditingMessage = computed(() => editingMessageId.value !== null);
   const lastMessage = ref('');
   const isTeleportedToBody = ref(false);
   const setIsTeleportedToBody = (isTeleported: boolean) => {
@@ -55,6 +63,7 @@ export const useAgentStore = defineStore('agent', () => {
     setCurrentChat,
     abortCurrentChatRequest,
     submitToolApproval: submitToolApprovalResponse,
+    sendEditMessage,
   } = createAgentChatManager({
     lastMessage,
     activeModeName,
@@ -275,6 +284,10 @@ export const useAgentStore = defineStore('agent', () => {
     }
   })
   watch(activeSessionId, (newVal: string | null) => {
+    // The edited message lives in the outgoing session's chat, so drop edit mode.
+    if (editingMessageId.value !== null) {
+      exitEditMode();
+    }
     if (newVal) {
       setLocalStorageItem('lastSessionId', newVal);
     }
@@ -448,6 +461,67 @@ export const useAgentStore = defineStore('agent', () => {
     addSystemMessage(RESERVED_SYSTEM_MESSAGE_CONTENT.AGENT_RESPONSE_ABORTED);
   }
 
+  function setEditingEnabled(enabled: boolean) {
+    editingEnabled.value = enabled;
+  }
+
+  // Enter edit mode for a user message: stash the current input, then load the
+  // message's text into the textarea for the user to amend. Allowed mid-generation —
+  // committing the edit stops the running turn (see submitEditMessage).
+  function startEditMessage(message: any) {
+    if (!editingEnabled.value) {
+      return;
+    }
+    const turnId = message?.metadata?.turnId;
+    const messageId = message?.id;
+    if (!turnId || !messageId) {
+      return;
+    }
+    if (editingMessageId.value === null) {
+      savedUserInput.value = userMessageInput.value ?? '';
+    }
+    const text = (message.parts ?? [])
+      .filter((part: any) => part.type === 'text')
+      .map((part: any) => part.text ?? '')
+      .join('');
+    editingMessageId.value = messageId;
+    editingMessageTurnId.value = turnId;
+    userMessageInput.value = text;
+    nextTick(() => focusTextInput());
+  }
+
+  // Leave edit mode and restore whatever the user had been typing before.
+  function exitEditMode() {
+    userMessageInput.value = savedUserInput.value;
+    savedUserInput.value = '';
+    editingMessageId.value = null;
+    editingMessageTurnId.value = null;
+  }
+
+  function cancelEditMessage() {
+    if (editingMessageId.value === null) {
+      return;
+    }
+    exitEditMode();
+    nextTick(() => focusTextInput());
+  }
+
+  async function submitEditMessage() {
+    if (editingMessageId.value === null) {
+      return;
+    }
+    const text = trimmedUserMessage.value;
+    if (!text) {
+      return;
+    }
+    const messageId = editingMessageId.value;
+    const turnId = editingMessageTurnId.value!;
+    steerBuffer.clear();
+    // Restore the stashed input and leave edit mode before the regeneration streams in.
+    exitEditMode();
+    await sendEditMessage({ messageId, turnId, text });
+  }
+
   function resolveInternalRoute(href: string): string | null {
     if (href.startsWith('#')) {
       return `${window.location.pathname}${window.location.search}${href}`;
@@ -533,6 +607,15 @@ export const useAgentStore = defineStore('agent', () => {
     getLocalStorageItem,
     addDebugMessage,
     abortCurrentChatRequestAndAddSystemMessage,
+    //_________-Message editing-_____________
+    editingEnabled,
+    setEditingEnabled,
+    isEditingMessage,
+    editingMessageId,
+    startEditMessage,
+    cancelEditMessage,
+    submitEditMessage,
+    //_______________________________________
     addSystemMessage,
     isAudioChatMode,
     setIsAudioChatMode,

package/dist/custom/conversation_area/MessageRenderer.vue

@@ -1,33 +1,77 @@
 <template>
-  <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"
+  <div 
+    class="relative flex flex-col w-full group/msg" 
   >
-    {{ $t('Steering instruction') }}
-  </div>
-  <ProcessingTimeline
-    :message="message"
-    :isLastMessageInChat="isLastMessageInChat"
-  />
-  <template 
-    v-for="(part, index) in getMessageParts(message)"
-    :key="part.type"
-  > 
-    <TextRenderer 
-      v-if="part.type === 'text' && !checkIfMessageSystemMessage(part.text ?? '')" 
-      :message="part.text" 
-      :role="props.message.role" 
-      :state="part.state ?? (props.message.role === 'user' ? 'done' : undefined)"
-    />
-    <ToolApprovalRenderer
-      v-else-if="part.type === 'data-tool-approval'"
-      :data="part.data ?? {}"
+      <div 
+        v-if="canEdit" 
+        class="absolute w-full h-[calc(100%+1.5rem)] pb-8"
+        @mouseenter="showEditButtonOnHover" 
+        @mouseleave="hideEditButtonOnHover"  
+      />
+      <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="canEdit && showEditButton"
+          class="absolute flex -bottom-6 right-0 self-end p-1 mr-4 mt-0.5 z-20"
+          @mouseenter="showEditButtonOnHover" 
+          @mouseleave="hideEditButtonOnHover" 
+        >
+          <button
+            type="button"
+            class="flex items-center justify-center w-8 h-8 rounded-md text-gray-400 hover:text-lightPrimary dark:hover:text-darkPrimary opacity-60 group-hover/msg:opacity-100 transition-opacity duration-150 hover:scale-110"
+            :title="$t('Copy message')"
+            @click="copyMessageToClipboard(message)"
+          >
+            <IconFileCopySolid class="w-5 h-5" />
+          </button>
+          <button
+            type="button"
+            class="flex items-center justify-center w-8 h-8 rounded-md text-gray-400 hover:text-lightPrimary dark:hover:text-darkPrimary opacity-60 group-hover/msg:opacity-100 transition-opacity duration-150 hover:scale-110"
+            :title="$t('Edit message')"
+            @click="agentStore.startEditMessage(message)"
+          >
+            <IconPenSolid class="w-5 h-5" />
+          </button>
+        </div>
+      </Transition>
+    <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"
     />
-    <SystemMessageRenderer 
-      v-else-if="part.type === 'text'"
-      :message="part.text" 
-    />
-  </template>
+    <template
+      v-for="(part, index) in getMessageParts(message)"
+      :key="part.type"
+    >
+      <TextRenderer
+        v-if="part.type === 'text' && !checkIfMessageSystemMessage(part.text ?? '')"
+        :message="part.text"
+        :role="props.message.role"
+        :highlight="isBeingEdited"
+        :state="part.state ?? (props.message.role === 'user' ? 'done' : undefined)"
+      />
+      <ToolApprovalRenderer
+        v-else-if="part.type === 'data-tool-approval'"
+        :data="part.data ?? {}"
+      />
+      <SystemMessageRenderer
+        v-else-if="part.type === 'text'"
+        :message="part.text"
+      />
+    </template>
+
+  </div>
 
 </template>
 
@@ -35,6 +79,8 @@
 
 
 <script setup lang="ts">
+  import { computed, ref } from 'vue';
+  import { IconPenSolid, IconFileCopySolid } from '@iconify-prerendered/vue-flowbite';
   import TextRenderer from './TextRenderer.vue';
   import type { IMessage } from '../types';
   import { getMessageParts } from '../utils';
@@ -42,14 +88,53 @@
   import SystemMessageRenderer from './SystemMessageRenderer.vue';
   import ToolApprovalRenderer from './ToolApprovalRenderer.vue';
   import { RESERVED_SYSTEM_MESSAGE_CONTENT } from '../composables/agentStore/constants';
+  import { useAgentStore } from '../composables/useAgentStore';
+  import { useAdminforth } from '@/adminforth';
 
-  const props = defineProps<{ 
-    message: IMessage 
+  const props = defineProps<{
+    message: IMessage
     isLastMessageInChat: boolean
   }>();
 
+  const agentStore = useAgentStore();
+  const { alert } = useAdminforth();
+  const showEditButton = ref(false);
+  // A user message is editable once it carries a turnId (loaded from history or stamped
+  // after its turn finished). Steer sub-messages and other roles are never editable, and
+  // we hide the affordance entirely while another edit or a live turn is in flight.
+  const canEdit = computed(() =>
+    agentStore.editingEnabled
+    && props.message.role === 'user'
+    && !props.message.metadata?.steer
+    && Boolean(props.message.metadata?.turnId)
+    && !agentStore.isEditingMessage
+  );
+
+  const isBeingEdited = computed(() =>
+    Boolean(props.message.id) && props.message.id === agentStore.editingMessageId
+  );
+
   function checkIfMessageSystemMessage(message: IMessage): boolean {
     const isReserved = Object.values(RESERVED_SYSTEM_MESSAGE_CONTENT).includes(message as RESERVED_SYSTEM_MESSAGE_CONTENT);
     return isReserved;
   }
+
+  function showEditButtonOnHover() {
+    showEditButton.value = true;
+  }
+
+  function hideEditButtonOnHover() {
+    showEditButton.value = false;
+  }
+
+  function copyMessageToClipboard(message: IMessage) {
+    navigator.clipboard.writeText(message.parts[0].text ?? '')
+      .then(() => {
+        alert({ message: 'Message copied to clipboard', variant: 'success' });
+      })
+      .catch((error) => {
+        console.error('Failed to copy message to clipboard:', error);
+        alert({ message: 'Failed to copy message to clipboard', variant: 'danger' });
+      });
+  }
 </script>

package/dist/custom/conversation_area/TextRenderer.vue

@@ -1,18 +1,20 @@
 <template>
   <div
-    class="flex items-center justify-center rounded-xl border px-6 border-gray-200 dark:border-gray-700 min-w-0"
+    class="flex items-center justify-center rounded-xl border px-6 border-gray-200 dark:border-gray-700 min-w-0 transition-shadow duration-150"
     @click="handleMarkdownLinkClick"
     :class="[
-      hasVegaLite ? 'w-full my-2' : '',
+      hasVegaLite ? 'w-full my-2' : 'm-2',
       props.role === 'user' ? 'bg-lightListTableHeading dark:bg-darkListTableHeading self-end max-w-[80%] mr-4' 
-        : 'border-none self-start max-w-full'
+        : 'border-none self-start max-w-full',
+      props.highlight ? 'ring-2 ring-lightPrimary dark:ring-darkPrimary w-full max-w-[calc(100%-2rem)]' : ''
     ]"
   >
     <IncremarkContent
       class="text-wrap break-words w-full max-w-full"
       v-if="content"
-      :content="content" 
-      :is-finished="isFinished" 
+      :key="renderNonce"
+      :content="content"
+      :is-finished="isFinished"
       :components="incremarkComponents"
       :incremark-options="incremarkOptions"
     />
@@ -33,7 +35,8 @@
   const props = defineProps<{
     message: string | undefined,
     state: string | undefined,
-    role: IMessage['role']
+    role: IMessage['role'],
+    highlight?: boolean
   }>();
 
   const emit = defineEmits(['toggle-thoughts']);
@@ -49,6 +52,13 @@
 
   const content = computed(() => props.message)
   const isFinished = computed(() => props.state === 'done')
+
+  const renderNonce = ref(0);
+  watch(content, (newContent, oldContent) => {
+    if (isFinished.value && newContent !== oldContent) {
+      renderNonce.value++;
+    }
+  });
   const hasVegaLite = computed(() => props.message?.includes('```vega-lite'))
   const isStateStreaming = computed(() => props.state === 'streaming')
 

package/dist/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",

package/dist/custom/types.ts

@@ -30,11 +30,18 @@ export interface IToolGroup {
 }
 
 export interface IMessage {
+  id?: string;
   role: 'user' | 'assistant' | 'system';
   metadata?: any,
   parts: IPart[];
 }
 
+export interface IStoredMessage {
+  role: 'user' | 'assistant' | 'system';
+  text: string;
+  turnId?: string;
+}
+
 export interface IAgentSession {
   sessionId: string;
   title: string;

package/dist/domain/agentEvents.d.ts

@@ -30,6 +30,10 @@ export type AgentEvent = {
     type: "transcript";
     text: string;
     language?: string;
+} | {
+    type: "turn-persisted";
+    sessionId: string;
+    turnId: string;
 } | {
     type: "response";
     text: string;

package/dist/domain/turnTypes.d.ts

@@ -63,6 +63,7 @@ export type RunAndPersistAgentResponseInput = BaseAgentTurnInput & {
     approvalDecision?: "approve" | "reject";
     failureLogMessage: string;
     abortLogMessage: string;
+    editTurnId?: string;
 };
 export type RunAndPersistAgentResponseResult = {
     text: string;
@@ -72,6 +73,9 @@ export type RunAndPersistAgentResponseResult = {
 };
 export type HandleTurnInput = TextAgentTurnInput;
 export type HandleSpeechTurnInput = SpeechAgentTurnInput;
+export type HandleEditTurnInput = TextAgentTurnInput & {
+    turnId: string;
+};
 /**
  * Provider-agnostic message passed from the application layer to the LLM port.
  * The infrastructure adapter maps it onto concrete LangChain messages.

package/dist/index.js

@@ -79,6 +79,8 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             getAdminforth: () => this.adminforth,
             getAgentSystemPrompt: this.getAgentSystemPrompt.bind(this),
             hasPersistentCheckpointer: Boolean(this.options.checkpointResource),
+            turnCheckpointsEnabled: Boolean(this.options.turnResource.checkpointIdField),
+            sessionResource: this.options.sessionResource,
             createDebugSink: createSequenceDebugCollector,
         });
         this.speechTurnService = new SpeechTurnService(this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase));
@@ -107,6 +109,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                     defaultModeName: this.options.modes[0].name,
                     stickByDefault: (_b = this.options.stickByDefault) !== null && _b !== void 0 ? _b : false,
                     hasAudioAdapter: Boolean(this.options.audioAdapter),
+                    editingEnabled: Boolean(this.options.checkpointResource && this.options.turnResource.checkpointIdField),
                 }
             });
             if (!this.adminforth.config.customization.customHeadItems) {
@@ -149,6 +152,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             adminforth: this.adminforth,
             options: this.options,
             handleTurn: this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase),
+            handleEditTurn: this.runTurnUseCase.handleEditTurn.bind(this.runTurnUseCase),
             handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
             steer: ({ sessionId, message }) => {
                 const { id } = this.steerBuffer.add(sessionId, message);

package/dist/llm/agentModels.d.ts

@@ -21,6 +21,7 @@ export type AgentRuntimeRunInput = {
     } | Command;
     context: AgentTurnContext;
     observability: AgentTurnObservability;
+    branchFromCheckpointId?: string;
 };
 type AgentChatModelSpec = {
     model: AgentChatModel;

package/dist/llm/agentRuntime.d.ts

@@ -24,4 +24,18 @@ export declare class AgentRuntime {
         models: AgentTurnModels;
         sessionId: string;
     }): Promise<unknown[]>;
+    /**
+     * Return the thread's latest (tip) checkpoint id, or null when the thread has no
+     * persisted state. Builds a minimal agent and reads its state — no model call is
+     * made. Called after a turn completes to record the turn's fork point for editing.
+     */
+    getLatestCheckpointId(input: {
+        models: AgentTurnModels;
+        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(sessionId: string): Promise<void>;
 }

package/dist/llm/agentRuntime.js

@@ -68,9 +68,9 @@ export class AgentRuntime {
                 recursionLimit: 100,
                 callbacks: [createAgentLlmMetricsLogger()],
                 signal: input.context.abortSignal,
-                configurable: {
-                    thread_id: input.context.sessionId,
-                },
+                configurable: Object.assign({ thread_id: input.context.sessionId }, (input.branchFromCheckpointId
+                    ? { checkpoint_id: input.branchFromCheckpointId }
+                    : {})),
                 context: toLangchainAgentContext(Object.assign(Object.assign({}, input.context), { adminBaseUrl: adminforth.config.baseUrlSlashed, emit: input.observability.emit, sequenceDebugSink })),
             });
         });
@@ -104,4 +104,43 @@ export class AgentRuntime {
             return tasks.flatMap((task) => (Array.isArray(task === null || task === void 0 ? void 0 : task.interrupts) ? task.interrupts : []));
         });
     }
+    /**
+     * Return the thread's latest (tip) checkpoint id, or null when the thread has no
+     * persisted state. Builds a minimal agent and reads its state — no model call is
+     * made. Called after a turn completes to record the turn's fork point for editing.
+     */
+    getLatestCheckpointId(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const apiBasedTools = this.options.toolProvider.getApiBasedTools();
+            const tools = yield this.options.toolProvider.getTools(apiBasedTools);
+            const agent = createAgent({
+                name: this.options.name,
+                model: input.models.model,
+                checkpointer: this.options.getCheckpointer(),
+                tools,
+                contextSchema,
+                middleware: [
+                    humanInTheLoopMiddleware({
+                        interruptOn: createHumanInTheLoopInterrupts(apiBasedTools),
+                        descriptionPrefix: "Tool execution pending approval",
+                    }),
+                ],
+            });
+            const state = yield agent.getState({
+                configurable: { thread_id: input.sessionId },
+            });
+            const checkpointId = (_b = (_a = state === null || state === void 0 ? void 0 : state.config) === null || _a === void 0 ? void 0 : _a.configurable) === null || _b === void 0 ? void 0 : _b.checkpoint_id;
+            return checkpointId ? String(checkpointId) : 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(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.options.getCheckpointer().deleteThread(sessionId);
+        });
+    }
 }

package/dist/llm/langGraphLlm.d.ts

@@ -22,4 +22,12 @@ export declare class LangGraphLlm implements LlmPort {
         completionAdapter: AgentModeCompletionAdapter;
         sessionId: string;
     }): Promise<PendingInterrupt[]>;
+    getLatestCheckpointId(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        sessionId: string;
+    }): Promise<string | null>;
+    resetThreadCheckpoints(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        sessionId: string;
+    }): Promise<void>;
 }

package/dist/llm/langGraphLlm.js

@@ -37,6 +37,7 @@ export class LangGraphLlm {
                 input: runtimeInput,
                 context: input.context,
                 observability: input.observability,
+                branchFromCheckpointId: input.branchFromCheckpointId,
             });
             return adaptRawStream(rawStream);
         });
@@ -51,4 +52,15 @@ export class LangGraphLlm {
             return normalizeInterrupts(raw);
         });
     }
+    getLatestCheckpointId(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this.modelFactory.create(input.completionAdapter);
+            return this.runtime.getLatestCheckpointId({ models, sessionId: input.sessionId });
+        });
+    }
+    resetThreadCheckpoints(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runtime.resetThreadCheckpoints(input.sessionId);
+        });
+    }
 }