@adminforth/agent 2.2.5 → 2.3.1

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/speech_recognition_frontend/MicrophoneButon.vue

@@ -27,6 +27,7 @@
             :isRecording="microphoneButtonMode === 'listen'"
             :amplitude="audioAmplitude"
           />
+          <Spinner v-if="isPolling" class="ml-2 w-4 h-4 text-lightButtonsText dark:text-darkButtonsText fill-lightButtonsBackground dark:fill-darkPrimary" />
         </div>
         <div v-else-if="microphoneButtonMode === 'generating'" class="flex items-center justify-center gap-2 text-white text-sm">
           <span class="w-3 h-3 bg-white rounded-sm" />
@@ -65,6 +66,7 @@ const hideAnimationDebounced = debounce(() => {
 const sendUserRecordDebounced = debounce(() => {
   sendRecordForTranscription();
 }, 500);
+const isPolling = ref(false);
 
 const isAudioChatMode = computed(() => agentStore.isAudioChatMode);
 
@@ -116,8 +118,10 @@ function toggleChatMode() {
 }
 
 async function onStartRecording() {
+  isPolling.value = true;
   await unlockAudio();
   await requestMicAndStartVAD(saidSomething, stopRecording, onAnySound);
+  isPolling.value = false;
   microphoneButtonMode.value = 'listen';
   agentAudio.playBeep(1000);
 }

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);
+        });
+    }
 }

package/dist/persistence/sessionStore.d.ts

@@ -17,9 +17,33 @@ export declare class AgentSessionStore {
      */
     appendSteerToCurrentTurn(sessionId: string, steerText: string): Promise<void>;
     getSessionTurns(sessionId: string): Promise<{
+        id: any;
         prompt: any;
         response: any;
     }[]>;
+    /**
+     * Ordered non-system (real conversation) turns with their stored checkpoint id.
+     * Used by message editing to locate the target turn and its previous turn's
+     * fork point. Stable order (`createdAt ASC, id ASC`) so positions never drift.
+     */
+    getAgentTurns(sessionId: string): Promise<{
+        id: any;
+        prompt: any;
+        response: any;
+        checkpointId: string | null;
+    }[]>;
+    /**
+     * Apply a message edit and branch: replace the edited turn's prompt and truncate
+     * everything after it. Deletes later turns FIRST, then updates the edited turn, so
+     * an interruption can only leave a consistent "truncated, edit-not-yet-applied"
+     * state (recoverable by retry) — never "edited but stale later turns remain".
+     * (AdminForth's resource API has no transactions, hence the deliberate ordering.)
+     */
+    editTurnAndTruncateAfter(input: {
+        sessionId: string;
+        turnId: string;
+        newPrompt: string;
+    }): Promise<void>;
     getPreviousUserMessages(sessionId: string): Promise<PreviousUserMessage[]>;
     getLatestTurn(sessionId: string): Promise<any>;
     getChatSurfaceSessionId(incoming: ChatSurfaceIncomingMessage): string;
@@ -29,6 +53,12 @@ export declare class AgentSessionStore {
         turnId: string;
         responseText: string;
         debugHistory?: unknown;
+        /**
+         * Tip checkpoint id for this turn. Persisted only when provided AND the field is
+         * configured — so aborted/failed turns (which pass undefined) never overwrite it
+         * with a stale value.
+         */
+        checkpointId?: string | null;
     }): Promise<void>;
     getResumeState(sessionId: string): Promise<{
         turnId: string;