diff --git a/packages/components/src/bubble/composables/useToolCall.ts b/packages/components/src/bubble/composables/useToolCall.ts
index 98389126b..8342e35db 100644
--- a/packages/components/src/bubble/composables/useToolCall.ts
+++ b/packages/components/src/bubble/composables/useToolCall.ts
@@ -3,7 +3,7 @@ import { BubbleContentRendererProps, ChatMessageContent } from '../index.type'
 import { getJsonrepair } from '../utils'
 import { useBubbleStore } from './useBubbleStore'
 
-const toolCallStatus = ['running', 'success', 'failed', 'cancelled'] as const
+const toolCallStatus = ['running', 'success', 'failed', 'cancelled', 'awaiting-approval', 'denied'] as const
 export type ToolCallStatus = (typeof toolCallStatus)[number]
 
 export const useToolCall = (
diff --git a/packages/components/src/bubble/renderers/Tool.vue b/packages/components/src/bubble/renderers/Tool.vue
index 1e51d6a30..5d59d46e4 100644
--- a/packages/components/src/bubble/renderers/Tool.vue
+++ b/packages/components/src/bubble/renderers/Tool.vue
@@ -1,5 +1,13 @@
 <script setup lang="ts">
-import { IconArrowDown, IconCancelled, IconError, IconLoading, IconPlugin } from '@opentiny/tiny-robot-svgs'
+import {
+  IconArrowDown,
+  IconCancelled,
+  IconClose,
+  IconError,
+  IconLoading,
+  IconPlugin,
+  IconWarning,
+} from '@opentiny/tiny-robot-svgs'
 import { type Component, computed, nextTick, ref, useCssModule, watch, watchEffect } from 'vue'
 import { ToolCallStatus, useBubbleEventFn, useToolCall } from '../composables'
 import { BubbleContentRendererProps, ChatMessageContent } from '../index.type'
@@ -22,8 +30,14 @@ const textAndIconMap = new Map<string, { text: string; icon: Component }>([
   ['cancelled', { text: '已取消', icon: IconCancelled }],
 ])
 
+const approvalTextAndIconMap = new Map<string, { text: string; icon: Component }>([
+  ['awaiting-approval', { text: '等待确认', icon: IconWarning }],
+  ['denied', { text: '已拒绝', icon: IconClose }],
+])
+
 const textAndIcon = computed(() => {
-  return textAndIconMap.get(state.value?.status || '') || { text: '', icon: IconPlugin }
+  const status = state.value?.status || ''
+  return textAndIconMap.get(status) || approvalTextAndIconMap.get(status) || { text: '', icon: IconPlugin }
 })
 
 const prettyJSON = (json: unknown, space = 2) => {
@@ -193,6 +207,7 @@ const handleClick = () => {
     flex-shrink: 0;
     display: flex;
     align-items: center;
+    gap: 8px;
   }
 
   .header-icon {
@@ -209,9 +224,14 @@ const handleClick = () => {
     }
 
     &.icon-failed,
-    &.icon-cancelled {
+    &.icon-cancelled,
+    &.icon-denied {
       color: var(--tr-color-error);
     }
+
+    &.icon-awaiting-approval {
+      color: var(--tr-color-warning, #e6a23c);
+    }
   }
 
   .expand-icon {
diff --git a/packages/kit/src/message/adapters/native.ts b/packages/kit/src/message/adapters/native.ts
index 9d4d38fa7..09da337e5 100644
--- a/packages/kit/src/message/adapters/native.ts
+++ b/packages/kit/src/message/adapters/native.ts
@@ -27,7 +27,8 @@ export const createNativeMessageAdapter = (): MessageStateAdapter => {
       requestState: state.requestState,
       processingState: state.processingState,
       messages: [...state.messages],
-      isProcessing: state.requestState === 'processing',
+      isProcessing: state.requestState === 'processing' || state.requestState === 'paused',
+      isPaused: state.requestState === 'paused',
     } satisfies PublicMessageState
   }
 
diff --git a/packages/kit/src/message/adapters/vue.ts b/packages/kit/src/message/adapters/vue.ts
index 3f7a9e486..98149c919 100644
--- a/packages/kit/src/message/adapters/vue.ts
+++ b/packages/kit/src/message/adapters/vue.ts
@@ -15,6 +15,7 @@ export interface VueMessageStateAdapter extends MessageStateAdapter {
   processingState: Ref<RequestProcessingState | undefined>
   messages: Ref<ChatMessage[]>
   isProcessing: ComputedRef<boolean>
+  isPaused: ComputedRef<boolean>
 }
 
 const toReactiveMessage = (message: ChatMessage) => reactive(message) as ChatMessage
@@ -45,7 +46,8 @@ export const createVueMessageAdapter = (): VueMessageStateAdapter => {
   const requestState = ref<RequestState>('idle')
   const processingState = ref<RequestProcessingState | undefined>(undefined)
   const messages = ref<ChatMessage[]>([])
-  const isProcessing = computed(() => requestState.value === 'processing')
+  const isProcessing = computed(() => requestState.value === 'processing' || requestState.value === 'paused')
+  const isPaused = computed(() => requestState.value === 'paused')
 
   const initialize = (initialState: InternalMessageState) => {
     if (initialized) {
@@ -72,6 +74,7 @@ export const createVueMessageAdapter = (): VueMessageStateAdapter => {
       processingState: processingState.value,
       messages: toPlainValue(messages.value),
       isProcessing: isProcessing.value,
+      isPaused: isPaused.value,
     } satisfies PublicMessageState
   }
 
@@ -127,6 +130,7 @@ export const createVueMessageAdapter = (): VueMessageStateAdapter => {
     processingState,
     messages,
     isProcessing,
+    isPaused,
     initialize,
     getState,
     createMessage,
diff --git a/packages/kit/src/message/core/engine.ts b/packages/kit/src/message/core/engine.ts
index 362d27c38..87407345a 100644
--- a/packages/kit/src/message/core/engine.ts
+++ b/packages/kit/src/message/core/engine.ts
@@ -11,6 +11,7 @@ import {
   MessageRuntime,
   MessageStateAdapter,
   RequestProcessingState,
+  RequestNextOptions,
   RequestState,
   ResponseProvider,
 } from '../types'
@@ -22,6 +23,13 @@ import {
   omitFields,
   pickFields,
 } from '../utils'
+import {
+  clearTurnSnapshot,
+  createTurnId,
+  loadTurnSnapshots,
+  saveTurnSnapshot,
+  serializeTurnData,
+} from './turnPersistence'
 
 type ChatCompletionChoice = ChatCompletion.Choice | ChatCompletionChunk.Choice
 
@@ -62,6 +70,121 @@ const isPluginDisabled = (plugin: MessageEnginePlugin, context: BasePluginContex
   return Boolean(plugin.disabled)
 }
 
+const getRestorableToolCallIds = (messages: ChatMessage[]) => {
+  const ids = new Set<string>()
+
+  for (const message of messages) {
+    if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {
+      continue
+    }
+
+    const toolCallState = (message.state?.toolCall as Record<string, { status?: string }> | undefined) ?? {}
+    for (const toolCall of message.tool_calls) {
+      const status = toolCallState[toolCall.id]?.status
+      if (status === undefined || status === 'awaiting-approval') {
+        ids.add(toolCall.id)
+      }
+    }
+  }
+
+  return ids
+}
+
+const findRestoredTurn = (messages: ChatMessage[], persistPausedTurn: boolean) => {
+  if (!persistPausedTurn) {
+    return undefined
+  }
+
+  const snapshots = loadTurnSnapshots()
+  if (snapshots.length === 0) {
+    return undefined
+  }
+
+  const messageToolCallIds = getRestorableToolCallIds(messages)
+  const matches = snapshots.filter((snapshot) =>
+    snapshot.toolCallIds.some((toolCallId) => messageToolCallIds.has(toolCallId)),
+  )
+
+  if (matches.length === 1) {
+    return matches[0]
+  }
+
+  // A turn snapshot is only meaningful when the conversation messages are available.
+  // Never restore a snapshot without a message match, because the tool call arguments
+  // and persisted tool statuses live in the conversation message history.
+  return undefined
+}
+
+const restorePendingToolCallStates = (messages: ChatMessage[], toolCallIds: string[]) => {
+  const toolCallIdSet = new Set(toolCallIds)
+
+  return messages.map((message) => {
+    if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {
+      return message
+    }
+
+    const pendingToolCallIds = message.tool_calls
+      .map((toolCall) => toolCall.id)
+      .filter((toolCallId) => toolCallIdSet.has(toolCallId))
+
+    if (pendingToolCallIds.length === 0) {
+      return message
+    }
+
+    const toolCallState = (message.state?.toolCall as Record<string, Record<string, unknown>> | undefined) ?? {}
+    const nextToolCallState = { ...toolCallState }
+    let changed = false
+
+    for (const toolCallId of pendingToolCallIds) {
+      if (toolCallState[toolCallId]?.status !== undefined) {
+        continue
+      }
+
+      nextToolCallState[toolCallId] = {
+        ...toolCallState[toolCallId],
+        status: 'awaiting-approval',
+      }
+      changed = true
+    }
+
+    if (!changed) {
+      return message
+    }
+
+    return {
+      ...message,
+      state: {
+        ...message.state,
+        toolCall: nextToolCallState,
+      },
+    }
+  })
+}
+
+const restoreCurrentTurn = (messages: ChatMessage[], toolCallIds: string[]) => {
+  const toolCallIdSet = new Set(toolCallIds)
+  const assistantIndex = messages.findIndex(
+    (message) =>
+      message.role === 'assistant' &&
+      Array.isArray(message.tool_calls) &&
+      message.tool_calls.some((toolCall) => toolCallIdSet.has(toolCall.id)),
+  )
+
+  if (assistantIndex === -1) {
+    return []
+  }
+
+  let turnStart = assistantIndex
+  for (let index = assistantIndex - 1; index >= 0; index -= 1) {
+    if (messages[index].role === 'user') {
+      turnStart = index
+      break
+    }
+  }
+
+  return messages.slice(turnStart)
+}
+
 export const createMessageEngine = (
   adapter: MessageStateAdapter,
   options: CreateMessageEngineOptions = {},
@@ -70,33 +193,60 @@ export const createMessageEngine = (
     initialMessages = [],
     requestMessageFields = [],
     requestMessageFieldsExclude = ['state', 'metadata', 'loading'],
+    persistPausedTurn = true,
     responseProvider: initialResponseProvider = defaultResponseProvider,
     onCompletionChunk,
     plugins: pluginsFromOptions = [],
   } = options
 
+  const createMessage = <T extends ChatMessage>(message: T): T => adapter.createMessage(message)
+
+  const restoredTurn = findRestoredTurn(initialMessages, persistPausedTurn)
+
+  const restoredMessages = restoredTurn
+    ? restorePendingToolCallStates(initialMessages, restoredTurn.toolCallIds)
+    : initialMessages
+  const runtimeMessages = restoredMessages.map((message) => createMessage(message))
+
   const initialState: InternalMessageState = {
-    requestState: 'idle',
-    processingState: undefined,
-    messages: [...initialMessages],
+    requestState: restoredTurn ? 'paused' : 'idle',
+    processingState: restoredTurn?.processingState,
+    messages: runtimeMessages,
   }
 
   adapter.initialize(initialState)
 
   const runtime: MessageRuntime = {
-    currentTurn: [],
-    customContext: {},
+    turnId: restoredTurn?.turnId ?? null,
+    currentTurn: restoredTurn ? restoreCurrentTurn(initialState.messages, restoredTurn.toolCallIds) : [],
+    customContext: restoredTurn?.customContext ?? {},
     abortController: null,
     responseProvider: initialResponseProvider,
+    commandHandlers: new Map(),
   }
 
   const defaultPlugins: MessageEnginePlugin[] = [thinkingPlugin(), lengthPlugin()]
   const plugins = deduplicatePlugins(defaultPlugins.concat(pluginsFromOptions))
 
   const getState = () => adapter.getState()
-  const createMessage = <T extends ChatMessage>(message: T): T => adapter.createMessage(message)
   const subscribe = adapter.subscribe
   const mutate = adapter.mutate
+  const pluginCommandOwners = new Map<string, MessageEnginePlugin>()
+
+  for (const plugin of plugins) {
+    if (!plugin.commands) {
+      continue
+    }
+
+    for (const [commandName, handler] of Object.entries(plugin.commands)) {
+      if (runtime.commandHandlers.has(commandName)) {
+        throw new Error(`Duplicate command name "${commandName}" detected.`)
+      }
+
+      runtime.commandHandlers.set(commandName, handler)
+      pluginCommandOwners.set(commandName, plugin)
+    }
+  }
 
   const objectDataIsValid = (obj: object | null | undefined) => {
     if (!obj || Object.keys(obj).length === 0) {
@@ -162,6 +312,225 @@ export const createMessageEngine = (
     setCustomContext,
   })
 
+  const finishTurnAfterRequest = async (abortSignal: AbortSignal) => {
+    const context = getBaseContext(abortSignal)
+
+    if (getState().requestState === 'paused') {
+      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
+        await plugin.onTurnPause?.(context)
+      }
+
+      persistCurrentPausedTurn()
+      return
+    }
+
+    setRequestState('completed')
+    for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
+      await plugin.onTurnEnd?.(context)
+    }
+
+    if (persistPausedTurn && runtime.turnId) {
+      clearTurnSnapshot(runtime.turnId)
+    }
+  }
+
+  async function runTurnLifecycle(options: { resume?: boolean } = {}) {
+    const ac = new AbortController()
+    runtime.abortController = ac
+
+    if (options.resume) {
+      if (persistPausedTurn && runtime.turnId) {
+        clearTurnSnapshot(runtime.turnId)
+      }
+    } else {
+      runtime.turnId ??= createTurnId()
+      runtime.customContext = {}
+    }
+
+    let assistantMessage: ChatMessage | null = null
+    const setAssistantMessage = (message: ChatMessage) => {
+      assistantMessage = message
+    }
+
+    try {
+      setRequestState('processing', 'requesting')
+
+      const baseContextAtStart = getBaseContext(ac.signal)
+      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, baseContextAtStart))) {
+        if (options.resume) {
+          await plugin.onTurnResume?.(baseContextAtStart)
+        } else {
+          await plugin.onTurnStart?.(baseContextAtStart)
+        }
+      }
+
+      const turnResponseProvider = runtime.responseProvider
+
+      try {
+        await executeRequest(turnResponseProvider, ac.signal, { setAssistantMessage })
+        await finishTurnAfterRequest(ac.signal)
+      } catch (error) {
+        if (
+          ac.signal.aborted ||
+          error instanceof AbortError ||
+          (error instanceof Error && error.name === 'AbortError')
+        ) {
+          setRequestState('aborted')
+        } else {
+          throw error
+        }
+      }
+    } catch (error) {
+      setRequestState('error')
+
+      let hasOnError = false
+      const context = getBaseContext(ac.signal)
+
+      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
+        if (plugin.onError) {
+          hasOnError = true
+          plugin.onError({ ...context, error })
+        }
+      }
+
+      if (!hasOnError) {
+        throw error
+      }
+    } finally {
+      const context = getBaseContext(ac.signal)
+      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
+        try {
+          plugin.onFinally?.(context)
+        } catch (error) {
+          console.error(`Error in onFinally hook for plugin [${plugin.name || 'Anonymous'}]:`, error)
+        }
+      }
+
+      runtime.abortController = null
+
+      // 暂停态保留当前回合，方便外部命令恢复时继续沿用同一轮上下文。
+      if (getState().requestState !== 'paused') {
+        runtime.currentTurn = []
+        runtime.turnId = null
+      }
+
+      mutate('messages', (_, skipNotify) => {
+        if (assistantMessage?.loading) {
+          assistantMessage.loading = undefined
+        } else {
+          skipNotify()
+        }
+      })
+    }
+  }
+
+  const dispatchCommand = async <Result = unknown>(command: string, payload?: unknown): Promise<Result> => {
+    const handler = runtime.commandHandlers.get(command)
+
+    if (!handler) {
+      throw new Error(`Unknown command "${command}"`)
+    }
+
+    const owner = pluginCommandOwners.get(command)
+    if (!owner) {
+      throw new Error(`Unknown command "${command}"`)
+    }
+
+    if (getState().requestState === 'processing') {
+      const hasAwaitingApprovalToolCall = getState().messages.some((message) => {
+        if (message.role !== 'assistant' || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
+          return false
+        }
+
+        const toolCallState = (message.state?.toolCall as Record<string, { status?: string }> | undefined) ?? {}
+        return message.tool_calls.some((toolCall) => {
+          const status = toolCallState[toolCall.id]?.status
+          return status === 'awaiting-approval'
+        })
+      })
+
+      if (!hasAwaitingApprovalToolCall) {
+        throw new Error('Cannot run plugin command while processing is in progress')
+      }
+
+      await new Promise<void>((resolve) => {
+        let unsubscribe = () => {}
+        const checkState = (currentState = getState()) => {
+          if (currentState.requestState !== 'processing') {
+            unsubscribe()
+            resolve()
+            return true
+          }
+
+          return false
+        }
+
+        unsubscribe = subscribe('requestState', (currentState) => {
+          checkState(currentState)
+        })
+
+        checkState()
+      })
+    }
+
+    const previousAbortController = runtime.abortController
+    const ac = new AbortController()
+    runtime.abortController = ac
+    const wasPaused = getState().requestState === 'paused'
+
+    let shouldRequest = false
+    let requestNextOptions: RequestNextOptions | undefined
+    let commandSucceeded = false
+    let shouldFinishTurn = false
+    let result: Result
+
+    try {
+      const baseContext = getBaseContext(ac.signal)
+      if (isPluginDisabled(owner, baseContext)) {
+        throw new Error(`Plugin command "${command}" is disabled.`)
+      }
+
+      const appendMessage = (message: ChatMessage | ChatMessage[]) => {
+        appendMessages(...(Array.isArray(message) ? message : [message]))
+      }
+
+      const requestNext = (options?: RequestNextOptions) => {
+        shouldRequest = true
+        requestNextOptions = options
+      }
+
+      result = (await handler(payload, { ...baseContext, appendMessage, requestNext })) as Result
+      commandSucceeded = true
+      shouldFinishTurn = wasPaused && !shouldRequest && getState().requestState !== 'paused'
+    } finally {
+      runtime.abortController = previousAbortController
+      if (
+        !previousAbortController &&
+        (!shouldRequest || !commandSucceeded) &&
+        getState().requestState !== 'paused' &&
+        !shouldFinishTurn
+      ) {
+        runtime.currentTurn = []
+      }
+    }
+
+    if (commandSucceeded && getState().requestState === 'paused') {
+      persistCurrentPausedTurn()
+    }
+
+    if (shouldRequest && !ac.signal.aborted) {
+      await runTurnLifecycle({ resume: requestNextOptions?.resume })
+    }
+
+    if (shouldFinishTurn) {
+      await finishTurnAfterRequest(ac.signal)
+      runtime.currentTurn = []
+      runtime.turnId = null
+    }
+
+    return result
+  }
+
   async function executeRequest(
     responseProvider: ResponseProvider,
     abortSignal: AbortSignal,
@@ -277,6 +646,50 @@ export const createMessageEngine = (
     await postRequest(assistantMessage, responseProvider, abortSignal, lastChoice, options)
   }
 
+  function persistCurrentPausedTurn() {
+    if (!persistPausedTurn || !runtime.turnId) {
+      return
+    }
+
+    const state = getState()
+    const toolCallIds = Array.from(
+      new Set(
+        state.messages.flatMap((message) => {
+          if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {
+            return []
+          }
+
+          const toolCallState = (message.state?.toolCall as Record<string, { status?: string }> | undefined) ?? {}
+          return message.tool_calls
+            .filter((toolCall) => {
+              const status = toolCallState[toolCall.id]?.status
+              return status === 'awaiting-approval'
+            })
+            .map((toolCall) => toolCall.id)
+        }),
+      ),
+    )
+
+    if (toolCallIds.length === 0) {
+      return
+    }
+
+    const customContext = serializeTurnData(runtime.customContext)
+    if (!customContext || typeof customContext !== 'object') {
+      return
+    }
+
+    saveTurnSnapshot({
+      version: 1,
+      turnId: runtime.turnId,
+      requestState: 'paused',
+      processingState: state.processingState,
+      toolCallIds,
+      customContext: customContext as Record<string, unknown>,
+      pausedAt: Date.now(),
+    })
+  }
+
   async function postRequest(
     currentMessage: ChatMessage,
     responseProvider: ResponseProvider,
@@ -299,7 +712,7 @@ export const createMessageEngine = (
           appendMessages(...(Array.isArray(message) ? message : [message]))
         }
 
-        const requestNext = () => {
+        const requestNext = (_options?: RequestNextOptions) => {
           shouldRequest = true
         }
 
@@ -322,92 +735,7 @@ export const createMessageEngine = (
   }
 
   async function runTurn() {
-    const ac = new AbortController()
-    runtime.abortController = ac
-    // 在每个回合开始时重置自定义上下文
-    runtime.customContext = {}
-
-    // 记录当前请求的 assistantMessage，方便在 finally 中进行状态清理（如将 loading 置为 false）
-    let assistantMessage: ChatMessage | null = null
-    const setAssistantMessage = (message: ChatMessage) => {
-      assistantMessage = message
-    }
-
-    try {
-      setRequestState('processing', 'requesting')
-      // 1) onTurnStart 串行执行，有错误则中断
-      const baseContextAtStart = getBaseContext(ac.signal)
-      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, baseContextAtStart))) {
-        await plugin.onTurnStart?.(baseContextAtStart)
-      }
-
-      // 在 onTurnStart 之后快照当前的 response provider
-      // 允许插件在 onTurnStart 钩子中修改 responseProvider
-      // 并在整个 turn 请求过程中防止因它发生变化而导致的不一致
-      const turnResponseProvider = runtime.responseProvider
-
-      try {
-        await executeRequest(turnResponseProvider, ac.signal, { setAssistantMessage })
-        setRequestState('completed')
-      } catch (error) {
-        // 检查是否是中止错误：优先检查当前使用的 AbortController 的信号状态
-        // 然后检查错误类型（instanceof 检查最准确）
-        // 最后通过 name 属性作为后备检查（处理跨模块/序列化等边界情况）
-        if (
-          ac.signal.aborted ||
-          error instanceof AbortError ||
-          (error instanceof Error && error.name === 'AbortError')
-        ) {
-          setRequestState('aborted')
-        } else {
-          throw error
-        }
-      }
-
-      // 3) onTurnEnd 串行执行，有错误则中断
-      const baseContextAtEnd = getBaseContext(ac.signal)
-      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, baseContextAtEnd))) {
-        await plugin.onTurnEnd?.(baseContextAtEnd)
-      }
-    } catch (error) {
-      setRequestState('error')
-
-      let hasOnError = false
-      const context = getBaseContext(ac.signal)
-
-      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
-        if (plugin.onError) {
-          hasOnError = true
-          plugin.onError({ ...context, error })
-        }
-      }
-
-      // 如果没有任何插件实现了 onError 钩子，则抛出错误
-      if (!hasOnError) {
-        throw error
-      }
-    } finally {
-      const context = getBaseContext(ac.signal)
-      for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
-        try {
-          plugin.onFinally?.(context)
-        } catch (error) {
-          console.error(`Error in onFinally hook for plugin [${plugin.name || 'Anonymous'}]:`, error)
-        }
-      }
-
-      runtime.abortController = null
-      runtime.currentTurn = []
-
-      // 如果请求立即出错，loading 可能一直为 true，这时需要手动将其置为 false
-      mutate('messages', (_, skipNotify) => {
-        if (assistantMessage?.loading) {
-          assistantMessage.loading = undefined
-        } else {
-          skipNotify()
-        }
-      })
-    }
+    await runTurnLifecycle()
   }
 
   async function sendMessage(content: string) {
@@ -417,7 +745,7 @@ export const createMessageEngine = (
       return
     }
 
-    if (getState().requestState === 'processing') {
+    if (getState().requestState === 'processing' || getState().requestState === 'paused') {
       console.warn('Cannot send message while processing is in progress')
       return
     }
@@ -434,7 +762,7 @@ export const createMessageEngine = (
 
   async function send(...msgs: ChatMessage[]) {
     // Validate current state - only allow sending when not processing
-    if (getState().requestState === 'processing') {
+    if (getState().requestState === 'processing' || getState().requestState === 'paused') {
       console.warn('Cannot send message while processing is in progress')
       return
     }
@@ -445,14 +773,40 @@ export const createMessageEngine = (
   }
 
   async function abort() {
+    if (getState().requestState === 'paused') {
+      const ac = new AbortController()
+      runtime.abortController = ac
+
+      try {
+        const context = getBaseContext(ac.signal)
+        for (const plugin of plugins.filter((plugin) => !isPluginDisabled(plugin, context))) {
+          await plugin.onTurnAbort?.(context)
+        }
+
+        if (getState().requestState === 'paused') {
+          setRequestState('aborted')
+        }
+
+        if (persistPausedTurn && runtime.turnId) {
+          clearTurnSnapshot(runtime.turnId)
+        }
+      } finally {
+        runtime.abortController = null
+        runtime.currentTurn = []
+        runtime.turnId = null
+      }
+
+      return
+    }
+
     runtime.abortController?.abort()
 
-    // 等待直到 isProcessing 变为 false
-    if (getState().isProcessing) {
+    // 仅等待实际请求结束；paused 是等待确认，不存在可 abort 的请求。
+    if (getState().requestState === 'processing') {
       await new Promise<void>((resolve) => {
         let unsubscribe = () => {}
         unsubscribe = subscribe('requestState', (currentState) => {
-          if (!currentState.isProcessing) {
+          if (currentState.requestState !== 'processing') {
             unsubscribe()
             resolve()
           }
@@ -467,6 +821,7 @@ export const createMessageEngine = (
     sendMessage,
     send,
     abort,
+    dispatchCommand,
     setResponseProvider(provider) {
       runtime.responseProvider = provider
     },
diff --git a/packages/kit/src/message/core/turnPersistence.ts b/packages/kit/src/message/core/turnPersistence.ts
new file mode 100644
index 000000000..3f9f6ef1b
--- /dev/null
+++ b/packages/kit/src/message/core/turnPersistence.ts
@@ -0,0 +1,211 @@
+import type { RequestProcessingState } from '../types'
+
+export const TURN_STATE_STORAGE_KEY = '__tiny-robot-turn'
+const TURN_STATE_VERSION = 1
+
+export interface PersistedTurnSnapshot {
+  /**
+   * Runtime metadata only. Conversation messages stay in the conversation storage
+   * and are supplied again as initialMessages when the engine is recreated.
+   */
+  version: typeof TURN_STATE_VERSION
+  turnId: string
+  requestState: 'paused'
+  processingState?: RequestProcessingState
+  toolCallIds: string[]
+  customContext: Record<string, unknown>
+  pausedAt: number
+}
+
+interface PersistedTurnStore {
+  version: typeof TURN_STATE_VERSION
+  turns: PersistedTurnSnapshot[]
+}
+
+const getLocalStorage = (): Storage | undefined => {
+  try {
+    if (typeof globalThis === 'undefined' || !('localStorage' in globalThis)) {
+      return undefined
+    }
+
+    return globalThis.localStorage
+  } catch {
+    return undefined
+  }
+}
+
+const toSerializable = (value: unknown, ancestors: WeakSet<object> = new WeakSet()): unknown => {
+  if (value === null || value === undefined) {
+    return value
+  }
+
+  if (typeof value === 'bigint') {
+    return value.toString()
+  }
+
+  if (typeof value === 'function' || typeof value === 'symbol') {
+    return undefined
+  }
+
+  if (typeof value !== 'object') {
+    return value
+  }
+
+  if (ancestors.has(value)) {
+    return undefined
+  }
+
+  ancestors.add(value)
+
+  let result: unknown
+  if (Array.isArray(value)) {
+    result = value.map((item) => toSerializable(item, ancestors))
+  } else {
+    const objectResult: Record<string, unknown> = {}
+    for (const [key, item] of Object.entries(value)) {
+      const serializableItem = toSerializable(item, ancestors)
+      if (serializableItem !== undefined) {
+        objectResult[key] = serializableItem
+      }
+    }
+    result = objectResult
+  }
+
+  ancestors.delete(value)
+  return result
+}
+
+const serialize = <T>(value: T): T | undefined => {
+  try {
+    const serializableValue = toSerializable(value)
+    return serializableValue === undefined ? undefined : (JSON.parse(JSON.stringify(serializableValue)) as T)
+  } catch {
+    return undefined
+  }
+}
+
+const parseStore = (value: string | null): PersistedTurnStore => {
+  if (!value) {
+    return { version: TURN_STATE_VERSION, turns: [] }
+  }
+
+  try {
+    const parsed = JSON.parse(value) as Partial<PersistedTurnStore>
+    if (parsed.version !== TURN_STATE_VERSION || !Array.isArray(parsed.turns)) {
+      return { version: TURN_STATE_VERSION, turns: [] }
+    }
+
+    const turns = parsed.turns.filter((turn): turn is PersistedTurnSnapshot => {
+      return Boolean(
+        turn &&
+        turn.version === TURN_STATE_VERSION &&
+        typeof turn.turnId === 'string' &&
+        turn.requestState === 'paused' &&
+        Array.isArray(turn.toolCallIds) &&
+        turn.customContext &&
+        typeof turn.customContext === 'object' &&
+        typeof turn.pausedAt === 'number',
+      )
+    })
+
+    return { version: TURN_STATE_VERSION, turns }
+  } catch {
+    return { version: TURN_STATE_VERSION, turns: [] }
+  }
+}
+
+const writeStore = (store: PersistedTurnStore) => {
+  const storage = getLocalStorage()
+  if (!storage) {
+    return
+  }
+
+  try {
+    storage.setItem(TURN_STATE_STORAGE_KEY, JSON.stringify(store))
+  } catch {
+    // Persistence is best effort. A full or unavailable localStorage must not break messaging.
+  }
+}
+
+export const loadTurnSnapshots = (): PersistedTurnSnapshot[] => {
+  const storage = getLocalStorage()
+  if (!storage) {
+    return []
+  }
+
+  try {
+    return parseStore(storage.getItem(TURN_STATE_STORAGE_KEY)).turns
+  } catch {
+    return []
+  }
+}
+
+export const saveTurnSnapshot = (snapshot: PersistedTurnSnapshot): void => {
+  const serializedSnapshot = serialize(snapshot)
+  if (!serializedSnapshot) {
+    return
+  }
+
+  const storage = getLocalStorage()
+  if (!storage) {
+    return
+  }
+
+  let storedValue: string | null = null
+  try {
+    storedValue = storage.getItem(TURN_STATE_STORAGE_KEY)
+  } catch {
+    return
+  }
+
+  const store = parseStore(storedValue)
+  const existingIndex = store.turns.findIndex((turn) => turn.turnId === snapshot.turnId)
+
+  if (existingIndex === -1) {
+    store.turns.push(serializedSnapshot)
+  } else {
+    store.turns[existingIndex] = serializedSnapshot
+  }
+
+  writeStore(store)
+}
+
+export const clearTurnSnapshot = (turnId: string): void => {
+  const storage = getLocalStorage()
+  if (!storage) {
+    return
+  }
+
+  let storedValue: string | null = null
+  try {
+    storedValue = storage.getItem(TURN_STATE_STORAGE_KEY)
+  } catch {
+    return
+  }
+
+  const store = parseStore(storedValue)
+  const turns = store.turns.filter((turn) => turn.turnId !== turnId)
+
+  if (turns.length === store.turns.length) {
+    return
+  }
+
+  if (turns.length === 0) {
+    try {
+      storage.removeItem(TURN_STATE_STORAGE_KEY)
+    } catch {
+      // Persistence is best effort.
+    }
+    return
+  }
+
+  writeStore({ ...store, turns })
+}
+
+export const createTurnId = (): string => {
+  return `turn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`
+}
+
+export const serializeTurnData = <T>(value: T): T => {
+  return serialize(value) ?? ({} as T)
+}
diff --git a/packages/kit/src/message/plugins/index.ts b/packages/kit/src/message/plugins/index.ts
index 9d5f6627b..9cc774660 100644
--- a/packages/kit/src/message/plugins/index.ts
+++ b/packages/kit/src/message/plugins/index.ts
@@ -3,4 +3,22 @@ export { getSkillRequestContext, skillPlugin } from './skillPlugin'
 export type { SkillPluginOptions, SkillRequestContext, SkillSelection } from './skillPlugin'
 export { thinkingPlugin } from './thinkingPlugin'
 export { toolPlugin } from './toolPlugin'
-export type { RuntimeTool, ToolCallContext, ToolProvider, ToolProviderItem, ToolSource } from './toolPlugin'
+export {
+  TOOL_REJECT_COMMAND,
+  TOOL_REJECT_TURN_COMMAND,
+  TOOL_RESUME_COMMAND,
+  TOOL_RESUME_TURN_COMMAND,
+} from './toolPlugin'
+export type {
+  RuntimeTool,
+  ToolCallContext,
+  ToolCallPauseOptions,
+  ToolCallPreparationContext,
+  ToolProvider,
+  ToolProviderItem,
+  ToolResumeCommandPayload,
+  ToolResumeCommandResult,
+  ToolTurnCommandPayload,
+  ToolTurnCommandResult,
+  ToolSource,
+} from './toolPlugin'
diff --git a/packages/kit/src/message/plugins/skillPlugin.ts b/packages/kit/src/message/plugins/skillPlugin.ts
index a3872560a..02ef133ee 100644
--- a/packages/kit/src/message/plugins/skillPlugin.ts
+++ b/packages/kit/src/message/plugins/skillPlugin.ts
@@ -53,12 +53,14 @@ type SkillSelectionStatus =
       phase: 'selecting'
       candidates: SkillCandidate[]
       preferredSkillNames?: string[]
+      maxSelectedSkills?: number
     }
   | {
       mode: 'auto'
       phase: 'ready'
       candidates: SkillCandidate[]
       preferredSkillNames?: string[]
+      maxSelectedSkills?: number
     }
 
 /**
@@ -88,7 +90,6 @@ export interface SkillRequestContext {
    * Instructions generated for the current skill selection state.
    */
   instructions: string[]
-  runtimeTools: RuntimeTool[]
   selection: SkillSelectionStatus
 }
 
@@ -225,6 +226,49 @@ const normalizeCandidates = (candidates: SkillCandidate[]) => {
   return [...candidateMap.values()]
 }
 
+const collectPendingSkillNames = (context: BasePluginContext) => {
+  const skillNames = new Set<string>()
+  const messages = [...context.currentTurn, ...context.getState().messages]
+
+  for (const message of messages) {
+    if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {
+      continue
+    }
+
+    const toolCallState = (message.state?.toolCall as Record<string, { status?: string }> | undefined) ?? {}
+    for (const toolCall of message.tool_calls) {
+      if (toolCallState[toolCall.id]?.status !== 'awaiting-approval') {
+        continue
+      }
+
+      if (toolCall.type !== 'function' || !('function' in toolCall)) {
+        continue
+      }
+
+      if (toolCall.function.name !== 'list_skill_files' && toolCall.function.name !== 'read_skill_file') {
+        continue
+      }
+
+      try {
+        const rawArguments = toolCall.function.arguments
+        const argumentsValue = typeof rawArguments === 'string' ? JSON.parse(rawArguments || '{}') : rawArguments
+        const skillName =
+          argumentsValue && typeof argumentsValue === 'object' && 'skillName' in argumentsValue
+            ? argumentsValue.skillName
+            : undefined
+
+        if (typeof skillName === 'string' && skillName.length > 0) {
+          skillNames.add(skillName)
+        }
+      } catch {
+        // The tool handler will report malformed arguments after the turn is resumed.
+      }
+    }
+  }
+
+  return [...skillNames]
+}
+
 /** Reads the skill context attached to a plugin lifecycle context. */
 export const getSkillRequestContext = (context: Pick<BasePluginContext, 'customContext'>) => {
   return context.customContext[skillPluginContextKey] as SkillRequestContext | undefined
@@ -287,6 +331,7 @@ const createAutoSelectionRuntimeTools = ({
   onInstructionsResolved,
   onSkillsResolved,
   onSkillSelectionResolved,
+  setRuntimeTools,
 }: {
   selection: AutoSkillSelection
   getSkillByName: SkillResolver['getSkillByName']
@@ -295,6 +340,7 @@ const createAutoSelectionRuntimeTools = ({
   onInstructionsResolved: SkillPluginHooks['onInstructionsResolved']
   onSkillsResolved: SkillPluginHooks['onSkillsResolved']
   onSkillSelectionResolved: SkillPluginHooks['onSkillSelectionResolved']
+  setRuntimeTools: (runtimeTools: RuntimeTool[]) => void
 }): RuntimeTool[] => {
   return createSkillSelectionRuntimeTools(candidates, {
     maxSelectedSkills: selection.maxSelectedSkills,
@@ -316,18 +362,20 @@ const createAutoSelectionRuntimeTools = ({
       )
 
       const instructions = createResolvedSkillInstructions(skills)
+      const runtimeTools = createSkillResourceRuntimeTools(skills)
+      setRuntimeTools(runtimeTools)
       const skillContext: SkillRequestContext = {
         skills,
         skillNames: skills.map((skill) => skill.name),
         requestedSkillNames,
         unresolvedSkillNames,
         instructions,
-        runtimeTools: createSkillResourceRuntimeTools(skills),
         selection: {
           mode: 'auto',
           phase: 'ready',
           candidates,
           preferredSkillNames,
+          maxSelectedSkills: selection.maxSelectedSkills,
         },
       }
 
@@ -357,13 +405,203 @@ export const skillPlugin = <S extends SkillSelection = SkillSelection>(
     ...restOptions
   } = options
 
+  let runtimeTools: RuntimeTool[] = []
+  let runtimeToolsReady = false
+
+  const setRuntimeTools = (nextRuntimeTools: RuntimeTool[]) => {
+    runtimeTools = nextRuntimeTools
+    runtimeToolsReady = true
+  }
+
+  const resolveRestoredSkills = async (skillContext: SkillRequestContext, context: BasePluginContext) => {
+    const selectionOptions = typeof selection === 'function' ? await selection(context) : selection
+
+    if (skillContext.selection.mode === 'manual' && selectionOptions.mode === 'manual' && selectionOptions.skills) {
+      const persistedSkillNames = new Set(skillContext.skillNames)
+      const skills = normalizeSkills(selectionOptions.skills).filter((skill) => persistedSkillNames.has(skill.name))
+      const pendingSkills = await resolvePendingSkills(
+        context,
+        skills.map((skill) => skill.name),
+      )
+      return normalizeSkills([...skills, ...pendingSkills])
+    }
+
+    let skills = skillContext.skills
+    if (skillContext.skillNames.length > 0 && getSkillByName) {
+      const result = await resolveSkillsByNames(skillContext.skillNames, getSkillByName, context)
+      if (result.skills.length > 0 || skillContext.skills.length === 0) {
+        skills = result.skills
+      }
+    }
+
+    const pendingSkills = await resolvePendingSkills(
+      context,
+      skills.map((skill) => skill.name),
+    )
+    return normalizeSkills([...skills, ...pendingSkills])
+  }
+
+  const resolvePendingSkills = async (context: BasePluginContext, excludedSkillNames: string[] = []) => {
+    const excludedNames = new Set(excludedSkillNames)
+    const pendingSkillNames = collectPendingSkillNames(context).filter((name) => !excludedNames.has(name))
+    if (pendingSkillNames.length === 0 || !getSkillByName) {
+      return []
+    }
+
+    const result = await resolveSkillsByNames(pendingSkillNames, getSkillByName, context)
+    return result.skills
+  }
+
+  const rebuildManualRuntimeTools = async (
+    selectionOptions: Extract<SkillSelection, { mode: 'manual' }>,
+    context: BasePluginContext,
+  ) => {
+    let skills: SkillDefinition[]
+    let requestedSkillNames: string[]
+    let unresolvedSkillNames: string[]
+
+    if (selectionOptions.skills) {
+      skills = normalizeSkills(selectionOptions.skills)
+      requestedSkillNames = skills.map((skill) => skill.name)
+      unresolvedSkillNames = []
+    } else {
+      requestedSkillNames = getUniqueStringArray(selectionOptions.skillNames) ?? []
+      if (!getSkillByName && requestedSkillNames.length > 0) {
+        setRuntimeTools([])
+        return
+      }
+
+      const result = getSkillByName
+        ? await resolveSkillsByNames(requestedSkillNames, getSkillByName, context)
+        : { skills: [], unresolvedSkillNames: [] }
+      skills = result.skills
+      unresolvedSkillNames = result.unresolvedSkillNames
+    }
+
+    setRuntimeTools(createSkillResourceRuntimeTools(skills))
+    setSkillContext(context, {
+      skills,
+      skillNames: skills.map((skill) => skill.name),
+      requestedSkillNames,
+      unresolvedSkillNames,
+      instructions: createResolvedSkillInstructions(skills),
+      selection: {
+        mode: 'manual',
+        phase: 'ready',
+      },
+    })
+  }
+
+  const rebuildRuntimeTools = async (context: BasePluginContext) => {
+    const skillContext = getSkillRequestContext(context)
+    const selectionOptions = typeof selection === 'function' ? await selection(context) : selection
+
+    if (!skillContext) {
+      if (selectionOptions.mode === 'manual') {
+        await rebuildManualRuntimeTools(selectionOptions, context)
+      } else if (selectionOptions.mode === 'auto') {
+        if (!getSkillCandidates || !getSkillByName) {
+          setRuntimeTools([])
+          return
+        }
+
+        const candidates = normalizeCandidates(await getSkillCandidates(context))
+        const candidateNameSet = new Set(candidates.map((candidate) => candidate.name))
+        const preferredSkillNames = getUniqueStringArray(selectionOptions.preferredSkillNames)?.filter((name) =>
+          candidateNameSet.has(name),
+        )
+        const runtimeTools = createAutoSelectionRuntimeTools({
+          selection: selectionOptions,
+          getSkillByName,
+          candidates,
+          preferredSkillNames,
+          onInstructionsResolved,
+          onSkillsResolved,
+          onSkillSelectionResolved,
+          setRuntimeTools,
+        })
+        setRuntimeTools(runtimeTools)
+        setSkillContext(context, {
+          skills: [],
+          skillNames: [],
+          requestedSkillNames: [],
+          unresolvedSkillNames: [],
+          instructions: candidates.length
+            ? [createSkillSelectionInstructions({ candidates, preferredSkillNames })]
+            : [],
+          selection: {
+            mode: 'auto',
+            phase: 'selecting',
+            candidates,
+            preferredSkillNames,
+            maxSelectedSkills: selectionOptions.maxSelectedSkills,
+          },
+        })
+      } else {
+        setRuntimeTools(createSkillResourceRuntimeTools(await resolvePendingSkills(context)))
+      }
+      return
+    }
+
+    if (skillContext.selection.mode === 'none') {
+      setRuntimeTools(createSkillResourceRuntimeTools(await resolvePendingSkills(context)))
+      return
+    }
+
+    if (skillContext.selection.mode === 'auto' && skillContext.selection.phase === 'selecting') {
+      const autoSelection: AutoSkillSelection =
+        selectionOptions.mode === 'auto'
+          ? selectionOptions
+          : {
+              mode: 'auto',
+              preferredSkillNames: skillContext.selection.preferredSkillNames,
+              maxSelectedSkills: skillContext.selection.maxSelectedSkills,
+            }
+
+      if (!getSkillByName) {
+        throw new Error('getSkillByName is required when restoring auto skill selection')
+      }
+
+      const nextRuntimeTools = createAutoSelectionRuntimeTools({
+        selection: autoSelection,
+        getSkillByName,
+        candidates: skillContext.selection.candidates,
+        preferredSkillNames: skillContext.selection.preferredSkillNames,
+        onInstructionsResolved,
+        onSkillsResolved,
+        onSkillSelectionResolved,
+        setRuntimeTools,
+      })
+      setRuntimeTools(nextRuntimeTools)
+      return
+    }
+
+    const skills = await resolveRestoredSkills(skillContext, context)
+    setRuntimeTools(createSkillResourceRuntimeTools(skills))
+
+    setSkillContext(context, {
+      ...skillContext,
+      skills,
+      skillNames: skills.map((skill) => skill.name),
+      unresolvedSkillNames: skillContext.requestedSkillNames.filter(
+        (skillName) => !skills.some((skill) => skill.name === skillName),
+      ),
+      instructions: createResolvedSkillInstructions(skills),
+    })
+  }
+
   return {
     name: 'skill',
     ...restOptions,
     provideTools: async (context: BasePluginContext) => {
-      return getSkillRequestContext(context)?.runtimeTools ?? []
+      if (!runtimeToolsReady) {
+        await rebuildRuntimeTools(context)
+      }
+
+      return runtimeTools
     },
     onTurnStart: async (context) => {
+      setRuntimeTools([])
       const selectionOptions: SkillSelection = typeof selection === 'function' ? await selection(context) : selection
 
       if (selectionOptions.mode === 'none') {
@@ -373,7 +611,6 @@ export const skillPlugin = <S extends SkillSelection = SkillSelection>(
           requestedSkillNames: [],
           unresolvedSkillNames: [],
           instructions: [],
-          runtimeTools: [],
           selection: {
             mode: 'none',
             phase: 'ready',
@@ -406,13 +643,13 @@ export const skillPlugin = <S extends SkillSelection = SkillSelection>(
         }
 
         const instructions = createResolvedSkillInstructions(skills)
+        setRuntimeTools(createSkillResourceRuntimeTools(skills))
         const skillContext: SkillRequestContext = {
           skills,
           skillNames: skills.map((skill) => skill.name),
           requestedSkillNames,
           unresolvedSkillNames,
           instructions,
-          runtimeTools: createSkillResourceRuntimeTools(skills),
           selection: {
             mode: 'manual',
             phase: 'ready',
@@ -446,26 +683,29 @@ export const skillPlugin = <S extends SkillSelection = SkillSelection>(
       }
       const instructions =
         candidates.length > 0 ? [createSkillSelectionInstructions({ candidates, preferredSkillNames })] : []
+      const runtimeTools = createAutoSelectionRuntimeTools({
+        selection: selectionOptions,
+        getSkillByName: resolveSkillByName,
+        candidates,
+        preferredSkillNames,
+        onInstructionsResolved,
+        onSkillsResolved,
+        onSkillSelectionResolved,
+        setRuntimeTools,
+      })
+      setRuntimeTools(runtimeTools)
       const skillContext: SkillRequestContext = {
         skills: [],
         skillNames: [],
         requestedSkillNames: [],
         unresolvedSkillNames: [],
         instructions,
-        runtimeTools: createAutoSelectionRuntimeTools({
-          selection: selectionOptions,
-          getSkillByName: resolveSkillByName,
-          candidates,
-          preferredSkillNames,
-          onInstructionsResolved,
-          onSkillsResolved,
-          onSkillSelectionResolved,
-        }),
         selection: {
           mode: 'auto',
           phase: 'selecting',
           candidates,
           preferredSkillNames,
+          maxSelectedSkills: selectionOptions.maxSelectedSkills,
         },
       }
 
@@ -474,5 +714,11 @@ export const skillPlugin = <S extends SkillSelection = SkillSelection>(
 
       return restOptions.onTurnStart?.(context)
     },
+    onTurnResume: async (context) => {
+      if (!runtimeToolsReady) {
+        await rebuildRuntimeTools(context)
+      }
+      return restOptions.onTurnResume?.(context)
+    },
   } satisfies MessageEnginePlugin & ToolProvider
 }
diff --git a/packages/kit/src/message/plugins/toolPlugin.ts b/packages/kit/src/message/plugins/toolPlugin.ts
index 94c736a2a..bfab32ac0 100644
--- a/packages/kit/src/message/plugins/toolPlugin.ts
+++ b/packages/kit/src/message/plugins/toolPlugin.ts
@@ -7,26 +7,97 @@ import {
 } from 'openai/resources'
 import type { MaybePromise, MaybeStreamableResult } from '../../types'
 import type { BasePluginContext, ChatMessage, MessageEnginePlugin, MutateMessageStateFn } from '../types'
-import { combineDeltaData, normalizeToAsyncGenerator } from '../utils'
+import { combineDeltaData, makeAbortable, normalizeToAsyncGenerator } from '../utils'
 
 type AssistantMessageWithState = ChatMessage<
   Record<string, unknown>,
   { toolCall?: Record<string, Record<string, unknown>> }
 >
 
+/**
+ * 工具来源标识，便于区分来自 toolPlugin、其他插件 provider，还是未知来源。
+ */
 export type ToolSource = { type: 'toolPlugin' } | { type: 'toolProvider'; pluginName?: string } | { type: 'unknown' }
 
+export type ToolCallPauseOptions = {
+  /**
+   * 暂停时写入 tool 消息的提示文案。
+   */
+  content?: string
+  /**
+   * 暂停原因，主要用于状态记录和外部审批链路追踪。
+   */
+  reason?: string
+}
+
 export type ToolCallContext = BasePluginContext & {
   assistantMessage: AssistantMessageWithState
+  /**
+   * 当前工具消息。
+   */
   toolMessage: ChatMessage
   /**
    * 当前工具的来源。
    */
   toolSource: ToolSource
+  /**
+   * 在工具正式执行前挂起当前 tool call。
+   */
+  pauseToolCall: (toolCallId: string, options?: ToolCallPauseOptions) => void
+}
+
+export type ToolCallPreparationContext = BasePluginContext & {
+  /**
+   * 当前 assistant 消息。
+   */
+  assistantMessage: AssistantMessageWithState
+  /**
+   * 在进入 callTool 前挂起当前 tool call。
+   */
+  pauseToolCall: (toolCallId: string, options?: ToolCallPauseOptions) => void
+}
+
+export const TOOL_RESUME_COMMAND = 'tool.resume'
+export const TOOL_REJECT_COMMAND = 'tool.reject'
+export const TOOL_RESUME_TURN_COMMAND = 'tool.resumeTurn'
+export const TOOL_REJECT_TURN_COMMAND = 'tool.rejectTurn'
+
+export type ToolResumeCommandPayload = {
+  /**
+   * 需要恢复或拒绝的 tool call id。
+   */
+  toolCallId: string
+  /**
+   * 恢复或拒绝时附带的说明。
+   */
+  reason?: string
+}
+
+/**
+ * 恢复或拒绝工具调用的命令执行结果。
+ */
+export type ToolResumeCommandResult =
+  | { status: 'resumed'; toolCallId: string }
+  | { status: 'rejected'; toolCallId: string }
+  | { status: 'missing'; toolCallId: string }
+
+export type ToolTurnCommandPayload = {
+  reason?: string
+}
+
+export type ToolTurnCommandResult = {
+  status: 'resumed' | 'rejected' | 'missing'
+  toolCallIds: string[]
 }
 
 export interface RuntimeTool {
+  /**
+   * runtime tool 的 schema 描述。
+   */
   tool: ChatCompletionFunctionTool
+  /**
+   * runtime tool 的执行函数。
+   */
   handler: (
     toolCall: ChatCompletionMessageFunctionToolCall,
     context: ToolCallContext,
@@ -36,15 +107,18 @@ export interface RuntimeTool {
 export type ToolProviderItem = ChatCompletionTool | RuntimeTool
 
 export interface ToolProvider {
+  /**
+   * 向 toolPlugin 提供工具列表。
+   */
   provideTools: (context: BasePluginContext) => MaybePromise<ToolProviderItem[]>
 }
 
 /**
- * 补全缺失的工具消息
- * 遍历所有 messages，找到所有 role 为 assistant 并且 tool_calls 数组不为空的 message。
- * 对每条这样的消息，检查其后是否存在对应的 tool 消息（通过 tool_call_id 匹配）。
- * 如果某个 tool_call_id 没有对应的 tool 消息，则在该 assistant 消息之后插入一条"工具调用已取消"的 tool 消息。
- * 插入操作从后往前执行，确保不影响已记录的索引位置。
+ * 修复历史消息中 assistant/tool 的配对关系。
+ *
+ * 当 assistant 已经发出了 tool_calls，但后续 tool 消息因为异常中断、人工拒绝、
+ * 或外部流程提前结束而没有补齐时，这里会自动插入“工具调用已取消”的占位消息，
+ * 让后续请求看到一条完整的消息链。
  */
 function fillMissingToolMessages({
   messages,
@@ -131,10 +205,15 @@ export const toolPlugin = (
     /**
      * 在处理包含 tool_calls 的响应前调用。
      */
-    beforeCallTools?: (
-      toolCalls: ChatCompletionMessageToolCall[],
-      context: BasePluginContext & { assistantMessage: AssistantMessageWithState },
-    ) => Promise<void>
+    beforeCallTools?: (toolCalls: ChatCompletionMessageToolCall[], context: ToolCallPreparationContext) => Promise<void>
+    /**
+     * 在每个工具调用正式执行前判断是否需要等待外部确认。
+     * 返回 true 时当前工具会进入 awaiting-approval，其他工具仍可继续执行。
+     */
+    shouldPauseToolCall?: (
+      toolCall: ChatCompletionMessageToolCall,
+      context: ToolCallContext,
+    ) => boolean | Promise<boolean>
     /**
      * 执行单个工具调用并返回其文本结果的函数。
      */
@@ -154,22 +233,30 @@ export const toolPlugin = (
      * 触发时机：工具调用完成（成功、失败或取消）时触发。
      * @param toolCall - 工具调用对象
      * @param context - 插件上下文，包含当前工具消息、状态和错误信息
-     * @param context.status - 工具调用状态：'success' | 'failed' | 'cancelled'
-     * @param context.error - 当状态为 'failed' 或 'cancelled' 时，可能包含错误信息
+     * @param context.status - 工具调用状态：'success' | 'failed' | 'cancelled' | 'denied'
+     * @param context.error - 当状态为 'failed'、'cancelled' 或 'denied' 时，可能包含错误信息
      */
     onToolCallEnd?: (
       toolCall: ChatCompletionMessageToolCall,
       context: ToolCallContext & {
-        status: 'success' | 'failed' | 'cancelled'
+        status: 'success' | 'failed' | 'cancelled' | 'denied'
         error?: Error
       },
     ) => void
+    /**
+     * 工具调用进入等待确认时使用的消息内容。
+     */
+    toolCallPausedContent?: string
     /**
      * 当请求被中止时用于工具调用取消的消息内容。
      */
     toolCallCancelledContent?: string
     /**
-     * 当工具调用执行失败（抛错或拒绝）时使用的消息内容。
+     * 当工具调用被拒绝时使用的消息内容。
+     */
+    toolCallDeniedContent?: string
+    /**
+     * 当工具调用执行失败（抛错）时使用的消息内容。
      */
     toolCallFailedContent?: string
     /**
@@ -183,10 +270,13 @@ export const toolPlugin = (
   const {
     getTools,
     beforeCallTools,
+    shouldPauseToolCall,
     callTool,
     onToolCallStart,
     onToolCallEnd,
+    toolCallPausedContent = 'Tool call awaiting confirmation.',
     toolCallCancelledContent = 'Tool call cancelled.',
+    toolCallDeniedContent = 'Tool call denied.',
     toolCallFailedContent = 'Tool call failed.',
     autoFillMissingToolMessages = false,
     ...restOptions
@@ -201,25 +291,31 @@ export const toolPlugin = (
     }
   }
 
-  const toolCallStart = (...args: Parameters<NonNullable<typeof onToolCallStart>>) => {
-    const [toolCall, { assistantMessage, mutate }] = args
-
+  const setToolCallState = (
+    assistantMessage: AssistantMessageWithState,
+    toolCallId: string,
+    patch: Record<string, unknown>,
+    mutate: MutateMessageStateFn,
+  ) => {
     mutate('messages', () => {
-      const message = ensureToolCallState(assistantMessage, toolCall.id)
-      message.state.toolCall[toolCall.id].status = 'running'
+      const message = ensureToolCallState(assistantMessage, toolCallId)
+      Object.assign(message.state.toolCall[toolCallId], patch)
     })
+  }
+
+  const toolCallStart = (...args: Parameters<NonNullable<typeof onToolCallStart>>) => {
+    const [toolCall, { assistantMessage, mutate }] = args
 
+    const toolCallStatus = assistantMessage.state?.toolCall?.[toolCall.id]?.status
+    if (toolCallStatus !== 'awaiting-approval') {
+      setToolCallState(assistantMessage, toolCall.id, { status: 'running' }, mutate)
+    }
     onToolCallStart?.(...args)
   }
 
   const toolCallEnd = (...args: Parameters<NonNullable<typeof onToolCallEnd>>) => {
     const [toolCall, { status, assistantMessage, mutate }] = args
-
-    mutate('messages', () => {
-      const message = ensureToolCallState(assistantMessage, toolCall.id)
-      message.state.toolCall[toolCall.id].status = status
-    })
-
+    setToolCallState(assistantMessage, toolCall.id, { status }, mutate)
     onToolCallEnd?.(...args)
   }
 
@@ -254,6 +350,205 @@ export const toolPlugin = (
 
   let currentToolResolution: ResolvedTools | undefined
 
+  const hasMeaningfulToolContent = (content: unknown) => {
+    if (typeof content === 'string') {
+      return content.trim().length > 0
+    }
+
+    if (Array.isArray(content)) {
+      return content.some((item) => {
+        if (typeof item === 'string') {
+          return item.trim().length > 0
+        }
+
+        if (item && typeof item === 'object' && 'text' in item && typeof item.text === 'string') {
+          return item.text.trim().length > 0
+        }
+
+        return Boolean(item)
+      })
+    }
+
+    if (content && typeof content === 'object') {
+      return Object.keys(content).length > 0
+    }
+
+    return Boolean(content)
+  }
+
+  const findPendingToolCall = (messages: ChatMessage[]) => {
+    let i = messages.length - 1
+    const toolMessages: ChatMessage[] = []
+
+    while (i >= 0 && messages[i].role === 'tool') {
+      toolMessages.unshift(messages[i])
+      i--
+    }
+
+    const assistantMessage = messages[i]
+    if (!assistantMessage || assistantMessage.role !== 'assistant') {
+      return null
+    }
+
+    if (!Array.isArray(assistantMessage.tool_calls) || assistantMessage.tool_calls.length === 0) {
+      return null
+    }
+
+    return {
+      assistantMessage,
+      toolMessages: toolMessages as Extract<ChatMessage, { role: 'tool' }>[],
+    }
+  }
+
+  const isAllToolCallsCompleted = (
+    assistantMessage: Extract<ChatMessage, { role: 'assistant' }> & AssistantMessageWithState,
+    toolMessages: Extract<ChatMessage, { role: 'tool' }>[],
+  ): boolean => {
+    const toolMessageMap = new Map(toolMessages.map((msg) => [msg.tool_call_id, msg]))
+    const toolCallState = assistantMessage.state?.toolCall as Record<string, Record<string, unknown>> | undefined
+
+    return (
+      assistantMessage.tool_calls?.every((toolCall) => {
+        const toolMessage = toolMessageMap.get(toolCall.id)
+        const toolCallStatus = toolCallState?.[toolCall.id]?.status
+
+        if (!toolMessage || toolCallStatus === 'running' || toolCallStatus === 'awaiting-approval') {
+          return false
+        }
+
+        return typeof toolCallStatus === 'string' || hasMeaningfulToolContent(toolMessage.content)
+      }) ?? false
+    )
+  }
+
+  const parsePauseCommandPayload = (payload: unknown): ToolResumeCommandPayload => {
+    if (!payload || typeof payload !== 'object') {
+      throw new Error('Tool pause/resume commands require an object payload with toolCallId.')
+    }
+
+    const { toolCallId, reason } = payload as { toolCallId?: unknown; reason?: unknown }
+
+    if (typeof toolCallId !== 'string' || !toolCallId) {
+      throw new Error('Tool pause/resume commands require a non-empty toolCallId.')
+    }
+
+    return {
+      toolCallId,
+      ...(typeof reason === 'string' && reason.length > 0 ? { reason } : {}),
+    }
+  }
+
+  const findPendingToolCallFromContext = (context: BasePluginContext) => {
+    const pendingFromTurn = context.currentTurn.length > 0 ? findPendingToolCall(context.currentTurn) : null
+
+    return pendingFromTurn ?? findPendingToolCall(context.getState().messages)
+  }
+
+  const createPauseToolCall =
+    (assistantMessage: AssistantMessageWithState, mutate: MutateMessageStateFn, toolMessage?: ChatMessage) =>
+    (toolCallId: string, pauseOptions: ToolCallPauseOptions = {}) => {
+      const now = Math.floor(Date.now() / 1000)
+      const content = pauseOptions.content ?? toolCallPausedContent
+
+      setToolCallState(
+        assistantMessage,
+        toolCallId,
+        {
+          status: 'awaiting-approval',
+          reason: pauseOptions.reason,
+          content,
+        },
+        mutate,
+      )
+
+      if (toolMessage) {
+        mutate('messages', () => {
+          toolMessage.content = content
+          toolMessage.metadata ??= {}
+          toolMessage.metadata.updatedAt = now
+        })
+      }
+    }
+
+  const processToolCall = async (
+    toolCall: ChatCompletionMessageToolCall,
+    contextWithToolMessage: ToolCallContext,
+    runtimeToolMap: Map<string, RuntimeTool>,
+    options: { skipStartHook?: boolean } = {},
+  ) => {
+    const { toolMessage: _toolMessage, abortSignal, mutate } = contextWithToolMessage
+    const toolMessage = _toolMessage as Extract<ChatMessage, { role: 'tool' }>
+    let hasMeaningfulResult = false
+
+    const functionToolCall = isFunctionToolCall(toolCall) ? toolCall : undefined
+    const runtimeTool = functionToolCall ? runtimeToolMap.get(functionToolCall.function.name) : undefined
+
+    if (options.skipStartHook) {
+      const assistantMessage = contextWithToolMessage.assistantMessage
+      setToolCallState(assistantMessage, toolCall.id, { status: 'running' }, mutate)
+    } else {
+      toolCallStart(toolCall, contextWithToolMessage)
+    }
+    try {
+      const result =
+        runtimeTool && functionToolCall
+          ? runtimeTool.handler(functionToolCall, contextWithToolMessage)
+          : callTool(toolCall, contextWithToolMessage)
+
+      const iterator = normalizeToAsyncGenerator(result)
+
+      for await (const chunk of iterator) {
+        mutate('messages', () => {
+          if (
+            (typeof chunk === 'string' && chunk.length > 0) ||
+            (chunk && typeof chunk === 'object' && Object.keys(chunk).length > 0)
+          ) {
+            hasMeaningfulResult = true
+          }
+
+          if (typeof chunk === 'string') {
+            toolMessage.content += chunk
+          } else {
+            let parsedContent: Record<string, any> = {}
+            try {
+              const content = Array.isArray(toolMessage.content)
+                ? toolMessage.content.map((item) => item.text).join('')
+                : toolMessage.content
+              parsedContent = JSON.parse(content || '{}')
+            } catch (error) {
+              console.warn(error)
+            }
+            toolMessage.content = JSON.stringify(combineDeltaData(parsedContent, chunk))
+          }
+
+          toolMessage.metadata ??= {}
+          toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+        })
+      }
+
+      toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'success' })
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error))
+
+      if (abortSignal.aborted) {
+        toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'cancelled', error: err })
+        return
+      }
+
+      console.error(error)
+
+      if (!hasMeaningfulResult) {
+        mutate('messages', () => {
+          toolMessage.content = toolCallFailedContent
+          toolMessage.metadata ??= {}
+          toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+        })
+      }
+
+      toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'failed', error: err })
+    }
+  }
+
   const resolveTools = async (
     context: BasePluginContext,
     existingTools: ChatCompletionTool[] = [],
@@ -320,9 +615,336 @@ export const toolPlugin = (
     return { tools, runtimeToolMap, toolSourceMap }
   }
 
+  const getAwaitingToolCalls = (assistantMessage: AssistantMessageWithState) => {
+    const toolCallState = assistantMessage.state?.toolCall ?? {}
+
+    return (assistantMessage.tool_calls ?? []).filter(
+      (toolCall) => toolCallState[toolCall.id]?.status === 'awaiting-approval',
+    )
+  }
+
+  const parseTurnCommandPayload = (payload: unknown): ToolTurnCommandPayload => {
+    if (payload === undefined || payload === null) {
+      return {}
+    }
+
+    if (typeof payload !== 'object') {
+      throw new Error('Tool turn commands require an object payload.')
+    }
+
+    const { reason } = payload as { reason?: unknown }
+    return typeof reason === 'string' && reason.length > 0 ? { reason } : {}
+  }
+
+  const ensureToolMessage = ({
+    toolCall,
+    toolMessages,
+    createMessage,
+    appendMessage,
+  }: {
+    toolCall: ChatCompletionMessageToolCall
+    toolMessages: Extract<ChatMessage, { role: 'tool' }>[]
+    createMessage: BasePluginContext['createMessage']
+    appendMessage: (message: ChatMessage | ChatMessage[]) => void
+  }) => {
+    let toolMessage = toolMessages.find((message) => message.tool_call_id === toolCall.id)
+
+    if (!toolMessage) {
+      const now = Math.floor(Date.now() / 1000)
+      toolMessage = createMessage({
+        role: 'tool',
+        tool_call_id: toolCall.id,
+        content: '',
+        metadata: {
+          createdAt: now,
+          updatedAt: now,
+        },
+      }) as Extract<ChatMessage, { role: 'tool' }>
+      appendMessage(toolMessage)
+    }
+
+    return toolMessage
+  }
+
+  const getToolSource = (toolCall: ChatCompletionMessageToolCall, toolSourceMap: Map<string, ToolSource>) => {
+    const functionToolCall = isFunctionToolCall(toolCall) ? toolCall : undefined
+    return functionToolCall
+      ? (toolSourceMap.get(functionToolCall.function.name) ?? { type: 'unknown' as const })
+      : { type: 'unknown' as const }
+  }
+
   return {
     name: 'tool',
     ...restOptions,
+    commands: {
+      [TOOL_RESUME_COMMAND]: async (payload, context) => {
+        const { toolCallId, reason } = parsePauseCommandPayload(payload)
+        const { createMessage, appendMessage, requestNext, setRequestState, mutate } = context
+
+        const pending = findPendingToolCallFromContext(context)
+
+        if (!pending) {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const assistantMessage = pending.assistantMessage as Extract<ChatMessage, { role: 'assistant' }> &
+          AssistantMessageWithState
+        const toolCall = assistantMessage.tool_calls?.find((call) => call.id === toolCallId)
+
+        if (!toolCall) {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const toolCallStatus = assistantMessage.state?.toolCall?.[toolCallId]?.status
+        if (toolCallStatus !== 'awaiting-approval') {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const toolMessage = ensureToolMessage({
+          toolCall,
+          toolMessages: pending.toolMessages,
+          createMessage,
+          appendMessage,
+        })
+
+        if (reason) {
+          setToolCallState(assistantMessage, toolCallId, { reason }, mutate)
+        }
+
+        setRequestState('processing', 'calling-tools')
+        const { runtimeToolMap, toolSourceMap } = await resolveTools(context, [])
+        const toolSource = getToolSource(toolCall, toolSourceMap)
+
+        mutate('messages', () => {
+          toolMessage.content = ''
+          toolMessage.metadata ??= {}
+          toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+        })
+
+        await processToolCall(
+          toolCall,
+          {
+            ...context,
+            assistantMessage,
+            toolMessage,
+            toolSource,
+            pauseToolCall: createPauseToolCall(assistantMessage, mutate, toolMessage),
+          },
+          runtimeToolMap,
+          { skipStartHook: true },
+        )
+
+        const latestPending = findPendingToolCallFromContext(context)
+        const latestToolMessages = latestPending?.toolMessages ?? []
+
+        if (isAllToolCallsCompleted(assistantMessage, latestToolMessages)) {
+          requestNext({ resume: true })
+        } else {
+          setRequestState('paused')
+        }
+
+        return { status: 'resumed', toolCallId } satisfies ToolResumeCommandResult
+      },
+      [TOOL_REJECT_COMMAND]: async (payload, context) => {
+        const { toolCallId, reason } = parsePauseCommandPayload(payload)
+        const { createMessage, appendMessage, setRequestState, mutate } = context
+
+        const pending = findPendingToolCallFromContext(context)
+
+        if (!pending) {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const assistantMessage = pending.assistantMessage as Extract<ChatMessage, { role: 'assistant' }> &
+          AssistantMessageWithState
+        const toolCall = assistantMessage.tool_calls?.find((call) => call.id === toolCallId)
+
+        if (!toolCall) {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const toolCallStatus = assistantMessage.state?.toolCall?.[toolCallId]?.status
+        if (toolCallStatus !== 'awaiting-approval') {
+          return { status: 'missing', toolCallId } satisfies ToolResumeCommandResult
+        }
+
+        const toolMessage = ensureToolMessage({
+          toolCall,
+          toolMessages: pending.toolMessages,
+          createMessage,
+          appendMessage,
+        })
+
+        if (reason) {
+          setToolCallState(assistantMessage, toolCallId, { reason }, mutate)
+        }
+
+        setRequestState('processing', 'calling-tools')
+        const { toolSourceMap } = await resolveTools(context, [])
+        const toolSource = getToolSource(toolCall, toolSourceMap)
+
+        mutate('messages', () => {
+          toolMessage.content = toolCallDeniedContent
+          toolMessage.metadata ??= {}
+          toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+        })
+
+        toolCallEnd(toolCall, {
+          ...context,
+          assistantMessage,
+          toolMessage,
+          toolSource,
+          pauseToolCall: createPauseToolCall(assistantMessage, mutate, toolMessage),
+          status: 'denied',
+          error: new Error(reason ?? 'Tool call rejected.'),
+        })
+
+        const latestPending = findPendingToolCallFromContext(context)
+        const latestToolMessages = latestPending?.toolMessages ?? []
+
+        if (isAllToolCallsCompleted(assistantMessage, latestToolMessages)) {
+          // Rejection terminates the current turn only when no other tool calls still await approval.
+          setRequestState('completed')
+        } else {
+          setRequestState('paused')
+        }
+
+        return { status: 'rejected', toolCallId } satisfies ToolResumeCommandResult
+      },
+      [TOOL_RESUME_TURN_COMMAND]: async (payload, context) => {
+        const { reason } = parseTurnCommandPayload(payload)
+        const { appendMessage, createMessage, requestNext, setRequestState, mutate } = context
+        const pending = findPendingToolCallFromContext(context)
+
+        if (!pending) {
+          return { status: 'missing', toolCallIds: [] } satisfies ToolTurnCommandResult
+        }
+
+        const assistantMessage = pending.assistantMessage as Extract<ChatMessage, { role: 'assistant' }> &
+          AssistantMessageWithState
+        const toolCalls = getAwaitingToolCalls(assistantMessage)
+
+        if (toolCalls.length === 0) {
+          return { status: 'missing', toolCallIds: [] } satisfies ToolTurnCommandResult
+        }
+
+        const toolMessages = toolCalls.map((toolCall) =>
+          ensureToolMessage({
+            toolCall,
+            toolMessages: pending.toolMessages,
+            createMessage,
+            appendMessage,
+          }),
+        )
+
+        if (reason) {
+          for (const toolCall of toolCalls) {
+            setToolCallState(assistantMessage, toolCall.id, { reason }, mutate)
+          }
+        }
+
+        setRequestState('processing', 'calling-tools')
+        const { runtimeToolMap, toolSourceMap } = await resolveTools(context, [])
+
+        await Promise.all(
+          toolCalls.map(async (toolCall, index) => {
+            const toolMessage = toolMessages[index]
+            mutate('messages', () => {
+              toolMessage.content = ''
+              toolMessage.metadata ??= {}
+              toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+            })
+
+            await processToolCall(
+              toolCall,
+              {
+                ...context,
+                assistantMessage,
+                toolMessage,
+                toolSource: getToolSource(toolCall, toolSourceMap),
+                pauseToolCall: createPauseToolCall(assistantMessage, mutate, toolMessage),
+              },
+              runtimeToolMap,
+              { skipStartHook: true },
+            )
+          }),
+        )
+
+        const latestPending = findPendingToolCallFromContext(context)
+        const latestToolMessages = latestPending?.toolMessages ?? []
+
+        if (isAllToolCallsCompleted(assistantMessage, latestToolMessages)) {
+          requestNext({ resume: true })
+        } else {
+          setRequestState('paused')
+        }
+
+        return {
+          status: 'resumed',
+          toolCallIds: toolCalls.map((toolCall) => toolCall.id),
+        } satisfies ToolTurnCommandResult
+      },
+      [TOOL_REJECT_TURN_COMMAND]: async (payload, context) => {
+        const { reason } = parseTurnCommandPayload(payload)
+        const { appendMessage, createMessage, setRequestState, mutate } = context
+        const pending = findPendingToolCallFromContext(context)
+
+        if (!pending) {
+          return { status: 'missing', toolCallIds: [] } satisfies ToolTurnCommandResult
+        }
+
+        const assistantMessage = pending.assistantMessage as Extract<ChatMessage, { role: 'assistant' }> &
+          AssistantMessageWithState
+        const toolCalls = getAwaitingToolCalls(assistantMessage)
+
+        if (toolCalls.length === 0) {
+          return { status: 'missing', toolCallIds: [] } satisfies ToolTurnCommandResult
+        }
+
+        const toolMessages = toolCalls.map((toolCall) =>
+          ensureToolMessage({
+            toolCall,
+            toolMessages: pending.toolMessages,
+            createMessage,
+            appendMessage,
+          }),
+        )
+        const { toolSourceMap } = await resolveTools(context, [])
+
+        setRequestState('processing', 'calling-tools')
+        for (const [index, toolCall] of toolCalls.entries()) {
+          const toolMessage = toolMessages[index]
+
+          if (reason) {
+            setToolCallState(assistantMessage, toolCall.id, { reason }, mutate)
+          }
+
+          mutate('messages', () => {
+            toolMessage.content = toolCallDeniedContent
+            toolMessage.metadata ??= {}
+            toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+          })
+
+          toolCallEnd(toolCall, {
+            ...context,
+            assistantMessage,
+            toolMessage,
+            toolSource: getToolSource(toolCall, toolSourceMap),
+            pauseToolCall: createPauseToolCall(assistantMessage, mutate, toolMessage),
+            status: 'denied',
+            error: new Error(reason ?? 'Tool call rejected.'),
+          })
+        }
+
+        setRequestState('completed')
+
+        return {
+          status: 'rejected',
+          toolCallIds: toolCalls.map((toolCall) => toolCall.id),
+        } satisfies ToolTurnCommandResult
+      },
+      ...restOptions.commands,
+    },
     onTurnStart: (context) => {
       const { getState, createMessage, mutate } = context
       const messages = getState().messages
@@ -333,6 +955,56 @@ export const toolPlugin = (
 
       return restOptions.onTurnStart?.(context)
     },
+    onTurnAbort: (context) => {
+      const pending = findPendingToolCallFromContext(context)
+
+      if (pending) {
+        const assistantMessage = pending.assistantMessage as Extract<ChatMessage, { role: 'assistant' }> &
+          AssistantMessageWithState
+        const toolCallState = assistantMessage.state?.toolCall ?? {}
+
+        for (const toolCall of assistantMessage.tool_calls ?? []) {
+          if (toolCallState[toolCall.id]?.status !== 'awaiting-approval') {
+            continue
+          }
+
+          const toolMessage = pending.toolMessages.find((message) => message.tool_call_id === toolCall.id)
+          setToolCallState(
+            assistantMessage,
+            toolCall.id,
+            { status: 'denied', reason: 'Tool call cancelled by user.' },
+            context.mutate,
+          )
+
+          if (toolMessage) {
+            context.mutate('messages', () => {
+              toolMessage.content = toolCallDeniedContent
+              toolMessage.metadata ??= {}
+              toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+            })
+
+            const functionToolCall = isFunctionToolCall(toolCall) ? toolCall : undefined
+            const toolSource = functionToolCall
+              ? (currentToolResolution?.toolSourceMap.get(functionToolCall.function.name) ?? {
+                  type: 'unknown' as const,
+                })
+              : { type: 'unknown' as const }
+
+            toolCallEnd(toolCall, {
+              ...context,
+              assistantMessage,
+              toolMessage,
+              toolSource,
+              pauseToolCall: createPauseToolCall(assistantMessage, context.mutate, toolMessage),
+              status: 'denied',
+              error: new Error('Tool call cancelled by user.'),
+            })
+          }
+        }
+      }
+
+      return restOptions.onTurnAbort?.(context)
+    },
     onBeforeRequest: async (context) => {
       const { requestBody } = context
 
@@ -359,13 +1031,17 @@ export const toolPlugin = (
       } = context
 
       if (lastChoice?.finish_reason !== 'tool_calls' || !currentMessage.tool_calls?.length) {
-        return
+        return restOptions.onAfterRequest?.(context)
       }
 
       setRequestState('processing', 'calling-tools')
+      const assistantMessage = currentMessage as AssistantMessageWithState
+      const pauseToolCall = createPauseToolCall(assistantMessage, mutate)
+
       await beforeCallTools?.(currentMessage.tool_calls as ChatCompletionMessageToolCall[], {
         ...context,
-        assistantMessage: currentMessage as AssistantMessageWithState,
+        assistantMessage,
+        pauseToolCall,
       })
 
       const { runtimeToolMap, toolSourceMap } = currentToolResolution ?? {
@@ -373,9 +1049,9 @@ export const toolPlugin = (
         toolSourceMap: new Map<string, ToolSource>(),
       }
 
+      let hasAwaitingApprovalToolCall = false
       const toolCallPromises = currentMessage.tool_calls.map(async (toolCall) => {
         const now = Math.floor(Date.now() / 1000)
-        let hasMeaningfulResult = false
         const toolMessage: ChatMessage = createMessage({
           role: 'tool',
           tool_call_id: toolCall.id,
@@ -395,85 +1071,68 @@ export const toolPlugin = (
 
         const contextWithToolMessage: ToolCallContext = {
           ...context,
-          assistantMessage: currentMessage as AssistantMessageWithState,
+          assistantMessage,
           toolMessage,
           toolSource,
+          pauseToolCall: createPauseToolCall(assistantMessage, mutate, toolMessage),
         }
 
-        toolCallStart(toolCall, contextWithToolMessage)
-        try {
-          const runtimeTool = functionToolCall ? runtimeToolMap.get(functionToolCall.function.name) : undefined
-          const result =
-            runtimeTool && functionToolCall
-              ? runtimeTool.handler(functionToolCall, contextWithToolMessage)
-              : callTool(toolCall, contextWithToolMessage)
-
-          // 将 Promise 或异步迭代器统一转换为异步生成器
-          const iterator = normalizeToAsyncGenerator(result)
-
-          // 迭代并逐步拼接内容到 content
-          for await (const chunk of iterator) {
-            mutate('messages', () => {
-              if (
-                (typeof chunk === 'string' && chunk.length > 0) ||
-                (chunk && typeof chunk === 'object' && Object.keys(chunk).length > 0)
-              ) {
-                hasMeaningfulResult = true
-              }
-
-              // 字符串拼接或 JSON 合并
-              if (typeof chunk === 'string') {
-                toolMessage.content += chunk
-              } else {
-                let parsedContent: Record<string, any> = {}
-                try {
-                  const content = Array.isArray(toolMessage.content)
-                    ? toolMessage.content.map((item) => item.text).join('')
-                    : toolMessage.content
-                  parsedContent = JSON.parse(content || '{}')
-                } catch (error) {
-                  console.warn(error)
-                }
-                toolMessage.content = JSON.stringify(combineDeltaData(parsedContent, chunk))
-              }
-
-              toolMessage.metadata!.updatedAt = Math.floor(Date.now() / 1000)
-            })
-          }
-
-          toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'success' })
-        } catch (error) {
-          const err = error instanceof Error ? error : new Error(String(error))
-
-          // 如果被 abort ，则抛出错误，主流程会处理状态
-          // 也可以不抛出错误，直接返回，主流程会自动处理 abort 场景
-          if (abortSignal.aborted) {
-            toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'cancelled', error: err })
-            // throw error
-            return
-          }
+        const initialToolCallStatus = assistantMessage.state?.toolCall?.[toolCall.id]?.status
+        if (initialToolCallStatus === 'awaiting-approval') {
+          hasAwaitingApprovalToolCall = true
+          mutate('messages', () => {
+            if (!hasMeaningfulToolContent(toolMessage.content)) {
+              toolMessage.content = toolCallPausedContent
+            }
+
+            toolMessage.metadata ??= {}
+            toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+          })
+          return
+        }
 
-          // 其他错误视为工具调用失败，则将工具消息内容设置为失败内容
-          console.error(error)
+        if (shouldPauseToolCall && (await shouldPauseToolCall(toolCall, contextWithToolMessage))) {
+          contextWithToolMessage.pauseToolCall(toolCall.id)
+          hasAwaitingApprovalToolCall = true
+          return
+        }
 
-          if (!hasMeaningfulResult) {
-            mutate('messages', () => {
-              toolMessage.content = toolCallFailedContent
-              toolMessage.metadata!.updatedAt = Math.floor(Date.now() / 1000)
-            })
-          }
+        toolCallStart(toolCall, contextWithToolMessage)
 
-          toolCallEnd(toolCall, { ...contextWithToolMessage, status: 'failed', error: err })
+        const awaitingApprovalStatus = assistantMessage.state?.toolCall?.[toolCall.id]?.status
+        if (awaitingApprovalStatus === 'awaiting-approval') {
+          hasAwaitingApprovalToolCall = true
+          mutate('messages', () => {
+            if (!hasMeaningfulToolContent(toolMessage.content)) {
+              toolMessage.content = toolCallPausedContent
+            }
+
+            toolMessage.metadata ??= {}
+            toolMessage.metadata.updatedAt = Math.floor(Date.now() / 1000)
+          })
+          return
         }
+
+        await processToolCall(toolCall, contextWithToolMessage, runtimeToolMap)
       })
 
-      await Promise.all(toolCallPromises)
-      currentToolResolution = undefined
+      await makeAbortable(Promise.all(toolCallPromises), abortSignal)
       if (!abortSignal.aborted) {
-        requestNext()
+        if (hasAwaitingApprovalToolCall) {
+          setRequestState('paused')
+        } else {
+          requestNext()
+        }
       }
 
       return restOptions.onAfterRequest?.(context)
     },
+    onFinally: (context) => {
+      try {
+        restOptions.onFinally?.(context)
+      } finally {
+        currentToolResolution = undefined
+      }
+    },
   }
 }
diff --git a/packages/kit/src/message/test/toolPlugin.test.ts b/packages/kit/src/message/test/toolPlugin.test.ts
index db47e34e2..a3ca30915 100644
--- a/packages/kit/src/message/test/toolPlugin.test.ts
+++ b/packages/kit/src/message/test/toolPlugin.test.ts
@@ -1,8 +1,24 @@
-import type { ChatCompletion, ChatCompletionFunctionTool, ChatCompletionTool } from 'openai/resources'
+import type {
+  ChatCompletion,
+  ChatCompletionFunctionTool,
+  ChatCompletionMessageToolCall,
+  ChatCompletionTool,
+} from 'openai/resources'
 import { describe, expect, it, vi } from 'vitest'
 import { createNativeMessageAdapter } from '../adapters/native'
 import { createMessageEngine } from '../core/engine'
-import { lengthPlugin, thinkingPlugin, toolPlugin, type RuntimeTool, type ToolProvider } from '../plugins'
+import {
+  lengthPlugin,
+  thinkingPlugin,
+  TOOL_REJECT_COMMAND,
+  TOOL_REJECT_TURN_COMMAND,
+  TOOL_RESUME_TURN_COMMAND,
+  TOOL_RESUME_COMMAND,
+  toolPlugin,
+  type RuntimeTool,
+  type ToolCallContext,
+  type ToolProvider,
+} from '../plugins'
 import type { CreateMessageEngineOptions, MessageEnginePlugin, ResponseProvider } from '../types'
 
 const silentDefaultPlugins = [thinkingPlugin({ disabled: true }), lengthPlugin({ disabled: true })]
@@ -445,4 +461,851 @@ describe('toolPlugin', () => {
 
     expect(responseProvider).toHaveBeenCalledOnce()
   })
+
+  it('pauses a tool call until an external resume command approves it', async () => {
+    let markPaused!: () => void
+    const paused = new Promise<void>((resolve) => {
+      markPaused = resolve
+    })
+    const callTool = vi.fn(async () => 'approved result')
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const hasToolResult = requestBody.messages.some((message) => message.role === 'tool')
+
+      if (!hasToolResult) {
+        return {
+          id: 'approval-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-approval',
+                    type: 'function',
+                    function: {
+                      name: 'sensitive_lookup',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(requestBody.messages.at(-1)).toMatchObject({
+        role: 'tool',
+        tool_call_id: 'call-approval',
+        content: 'approved result',
+      })
+      return {
+        id: 'approval-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'done',
+            },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          getTools: async () => [
+            {
+              type: 'function',
+              function: {
+                name: 'sensitive_lookup',
+              },
+            },
+          ],
+          callTool,
+          onToolCallStart(toolCall, context) {
+            context.pauseToolCall(toolCall.id, {
+              content: 'Awaiting approval.',
+              reason: 'manual-review',
+            })
+            markPaused()
+          },
+        }),
+      ],
+      responseProvider,
+    })
+
+    const turn = engine.sendMessage('run sensitive lookup')
+    await paused
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(engine.getState()).toMatchObject({
+      requestState: 'paused',
+      processingState: undefined,
+      isProcessing: true,
+      isPaused: true,
+    })
+    expect(engine.getState().messages[1]).toMatchObject({
+      role: 'assistant',
+      state: {
+        toolCall: {
+          'call-approval': {
+            status: 'awaiting-approval',
+            reason: 'manual-review',
+            content: 'Awaiting approval.',
+          },
+        },
+      },
+    })
+    expect(engine.getState().messages[2]).toMatchObject({
+      role: 'tool',
+      tool_call_id: 'call-approval',
+      content: 'Awaiting approval.',
+    })
+    expect(callTool).not.toHaveBeenCalled()
+
+    await expect(
+      engine.dispatchCommand(TOOL_RESUME_COMMAND, {
+        toolCallId: 'call-approval',
+      }),
+    ).resolves.toEqual({
+      status: 'resumed',
+      toolCallId: 'call-approval',
+    })
+
+    await turn
+
+    expect(callTool).toHaveBeenCalledOnce()
+    expect(responseProvider).toHaveBeenCalledTimes(2)
+    expect(engine.getState()).toMatchObject({
+      requestState: 'completed',
+      isPaused: false,
+    })
+    expect(engine.getState().messages.at(-1)).toMatchObject({
+      role: 'assistant',
+      content: 'done',
+    })
+
+    await expect(
+      engine.dispatchCommand(TOOL_RESUME_COMMAND, {
+        toolCallId: 'call-approval',
+      }),
+    ).resolves.toEqual({
+      status: 'missing',
+      toolCallId: 'call-approval',
+    })
+  })
+
+  it('pauses and resumes all tool calls as one turn', async () => {
+    const callTool = vi.fn(async (toolCall: ChatCompletionMessageToolCall) => `${toolCall.id} result`)
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const toolMessages = requestBody.messages.filter((message) => message.role === 'tool')
+
+      if (toolMessages.length === 0) {
+        return {
+          id: 'turn-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-first',
+                    type: 'function',
+                    function: { name: 'first_tool', arguments: '{}' },
+                  },
+                  {
+                    id: 'call-second',
+                    type: 'function',
+                    function: { name: 'second_tool', arguments: '{}' },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(toolMessages).toHaveLength(2)
+      expect(toolMessages.map((message) => message.content)).toEqual(['call-first result', 'call-second result'])
+      return {
+        id: 'turn-tool-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'turn done' },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          shouldPauseToolCall: async () => true,
+          getTools: async () => [
+            { type: 'function', function: { name: 'first_tool' } },
+            { type: 'function', function: { name: 'second_tool' } },
+          ],
+          callTool,
+        }),
+      ],
+      responseProvider,
+    })
+
+    await engine.sendMessage('run all tools')
+
+    expect(engine.getState()).toMatchObject({ requestState: 'paused', isPaused: true })
+    expect(engine.getState().messages[1]).toMatchObject({
+      state: {
+        toolCall: {
+          'call-first': { status: 'awaiting-approval' },
+          'call-second': { status: 'awaiting-approval' },
+        },
+      },
+    })
+    expect(callTool).not.toHaveBeenCalled()
+
+    await expect(engine.dispatchCommand(TOOL_RESUME_TURN_COMMAND)).resolves.toEqual({
+      status: 'resumed',
+      toolCallIds: ['call-first', 'call-second'],
+    })
+
+    expect(callTool).toHaveBeenCalledTimes(2)
+    expect(responseProvider).toHaveBeenCalledTimes(2)
+    expect(engine.getState()).toMatchObject({ requestState: 'completed', isPaused: false })
+    expect(engine.getState().messages.at(-1)).toMatchObject({
+      role: 'assistant',
+      content: 'turn done',
+    })
+  })
+
+  it('pauses only tools selected by shouldPauseToolCall', async () => {
+    const callTool = vi.fn(async (toolCall: ChatCompletionMessageToolCall) => `${toolCall.id} result`)
+    const shouldPauseToolCall = vi.fn(async (toolCall: ChatCompletionMessageToolCall, context: ToolCallContext) => {
+      expect(context.toolMessage).toMatchObject({ role: 'tool', tool_call_id: toolCall.id })
+      return toolCall.type === 'function' && toolCall.function.name === 'sensitive_tool'
+    })
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const toolMessages = requestBody.messages.filter((message) => message.role === 'tool')
+
+      if (toolMessages.length === 0) {
+        return {
+          id: 'selective-pause-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-safe',
+                    type: 'function',
+                    function: { name: 'safe_tool', arguments: '{}' },
+                  },
+                  {
+                    id: 'call-sensitive',
+                    type: 'function',
+                    function: { name: 'sensitive_tool', arguments: '{}' },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(toolMessages).toHaveLength(2)
+      expect(toolMessages.map((message) => message.content)).toEqual(['call-safe result', 'call-sensitive result'])
+      return {
+        id: 'selective-pause-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'selective pause done' },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          getTools: async () => [
+            { type: 'function', function: { name: 'safe_tool' } },
+            { type: 'function', function: { name: 'sensitive_tool' } },
+          ],
+          shouldPauseToolCall,
+          callTool,
+        }),
+      ],
+      responseProvider,
+    })
+
+    await engine.sendMessage('run selective tools')
+
+    expect(engine.getState()).toMatchObject({ requestState: 'paused', isPaused: true })
+    expect(callTool).toHaveBeenCalledOnce()
+    expect(callTool).toHaveBeenCalledWith(expect.objectContaining({ id: 'call-safe' }), expect.any(Object))
+    expect(engine.getState().messages[1]).toMatchObject({
+      state: {
+        toolCall: {
+          'call-safe': { status: 'success' },
+          'call-sensitive': { status: 'awaiting-approval' },
+        },
+      },
+    })
+    expect(responseProvider).toHaveBeenCalledOnce()
+
+    await expect(
+      engine.dispatchCommand(TOOL_RESUME_COMMAND, {
+        toolCallId: 'call-sensitive',
+      }),
+    ).resolves.toEqual({
+      status: 'resumed',
+      toolCallId: 'call-sensitive',
+    })
+
+    expect(callTool).toHaveBeenCalledTimes(2)
+    expect(responseProvider).toHaveBeenCalledTimes(2)
+    expect(engine.getState()).toMatchObject({ requestState: 'completed', isPaused: false })
+    expect(engine.getState().messages.at(-1)).toMatchObject({
+      role: 'assistant',
+      content: 'selective pause done',
+    })
+  })
+
+  it('denies an awaiting tool call without starting a follow-up request', async () => {
+    let markPaused!: () => void
+    const paused = new Promise<void>((resolve) => {
+      markPaused = resolve
+    })
+    const callTool = vi.fn(async () => 'should not run')
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const hasToolResult = requestBody.messages.some((message) => message.role === 'tool')
+
+      if (!hasToolResult) {
+        return {
+          id: 'rejection-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-rejection',
+                    type: 'function',
+                    function: {
+                      name: 'sensitive_delete',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(requestBody.messages.at(-1)).toMatchObject({
+        role: 'tool',
+        tool_call_id: 'call-rejection',
+        content: 'Tool call denied.',
+      })
+      return {
+        id: 'rejection-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'denied',
+            },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          getTools: async () => [
+            {
+              type: 'function',
+              function: {
+                name: 'sensitive_delete',
+              },
+            },
+          ],
+          callTool,
+          onToolCallStart(toolCall, context) {
+            context.pauseToolCall(toolCall.id)
+            markPaused()
+          },
+        }),
+      ],
+      responseProvider,
+    })
+
+    const turn = engine.sendMessage('delete sensitive data')
+    await paused
+
+    await expect(
+      engine.dispatchCommand(TOOL_REJECT_COMMAND, {
+        toolCallId: 'call-rejection',
+        reason: 'approval denied',
+      }),
+    ).resolves.toEqual({
+      status: 'rejected',
+      toolCallId: 'call-rejection',
+    })
+
+    await turn
+
+    expect(callTool).not.toHaveBeenCalled()
+    expect(responseProvider).toHaveBeenCalledTimes(1)
+    expect(engine.getState()).toMatchObject({
+      requestState: 'completed',
+      isPaused: false,
+    })
+    expect(engine.getState().messages[1]).toMatchObject({
+      role: 'assistant',
+      state: {
+        toolCall: {
+          'call-rejection': {
+            status: 'denied',
+          },
+        },
+      },
+    })
+    expect(engine.getState().messages.at(-1)).toMatchObject({
+      role: 'tool',
+      content: 'Tool call denied.',
+    })
+  })
+
+  it('keeps the turn paused when only one of multiple awaiting tool calls is rejected', async () => {
+    const callTool = vi.fn(async () => 'should not run')
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const toolMessages = requestBody.messages.filter((message) => message.role === 'tool')
+
+      if (toolMessages.length > 0) {
+        throw new Error('partial rejection should not start a follow-up request')
+      }
+
+      return {
+        id: 'partial-rejection-tool-call',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: '',
+              tool_calls: [
+                {
+                  id: 'call-reject-one',
+                  type: 'function',
+                  function: { name: 'first_tool', arguments: '{}' },
+                },
+                {
+                  id: 'call-still-awaiting',
+                  type: 'function',
+                  function: { name: 'second_tool', arguments: '{}' },
+                },
+              ],
+            },
+            finish_reason: 'tool_calls',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          shouldPauseToolCall: async () => true,
+          getTools: async () => [
+            { type: 'function', function: { name: 'first_tool' } },
+            { type: 'function', function: { name: 'second_tool' } },
+          ],
+          callTool,
+        }),
+      ],
+      responseProvider,
+    })
+
+    await engine.sendMessage('reject one tool')
+
+    await expect(
+      engine.dispatchCommand(TOOL_REJECT_COMMAND, {
+        toolCallId: 'call-reject-one',
+        reason: 'manual rejection',
+      }),
+    ).resolves.toEqual({
+      status: 'rejected',
+      toolCallId: 'call-reject-one',
+    })
+
+    expect(callTool).not.toHaveBeenCalled()
+    expect(responseProvider).toHaveBeenCalledOnce()
+    expect(engine.getState()).toMatchObject({ requestState: 'paused', isPaused: true })
+    expect(engine.getState().messages[1]).toMatchObject({
+      state: {
+        toolCall: {
+          'call-reject-one': { status: 'denied', reason: 'manual rejection' },
+          'call-still-awaiting': { status: 'awaiting-approval' },
+        },
+      },
+    })
+    expect(engine.getState().messages[2]).toMatchObject({
+      role: 'tool',
+      tool_call_id: 'call-reject-one',
+      content: 'Tool call denied.',
+    })
+    expect(engine.getState().messages[3]).toMatchObject({
+      role: 'tool',
+      tool_call_id: 'call-still-awaiting',
+      content: 'Tool call awaiting confirmation.',
+    })
+  })
+
+  it('rejects all awaiting tool calls as one turn', async () => {
+    const callTool = vi.fn(async () => 'should not run')
+    const responseProvider = vi.fn<ResponseProvider>(
+      async () =>
+        ({
+          id: 'turn-rejection-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-reject-first',
+                    type: 'function',
+                    function: { name: 'first_tool', arguments: '{}' },
+                  },
+                  {
+                    id: 'call-reject-second',
+                    type: 'function',
+                    function: { name: 'second_tool', arguments: '{}' },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        }) as ChatCompletion,
+    )
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          shouldPauseToolCall: async () => true,
+          getTools: async () => [
+            { type: 'function', function: { name: 'first_tool' } },
+            { type: 'function', function: { name: 'second_tool' } },
+          ],
+          callTool,
+        }),
+      ],
+      responseProvider,
+    })
+
+    await engine.sendMessage('reject all tools')
+
+    await expect(engine.dispatchCommand(TOOL_REJECT_TURN_COMMAND, { reason: 'manual rejection' })).resolves.toEqual({
+      status: 'rejected',
+      toolCallIds: ['call-reject-first', 'call-reject-second'],
+    })
+
+    expect(callTool).not.toHaveBeenCalled()
+    expect(responseProvider).toHaveBeenCalledOnce()
+    expect(engine.getState()).toMatchObject({ requestState: 'completed', isPaused: false })
+    expect(engine.getState().messages[1]).toMatchObject({
+      state: {
+        toolCall: {
+          'call-reject-first': { status: 'denied', reason: 'manual rejection' },
+          'call-reject-second': { status: 'denied', reason: 'manual rejection' },
+        },
+      },
+    })
+  })
+
+  it('denies awaiting tool calls when the paused turn is aborted', async () => {
+    let markPaused!: () => void
+    const paused = new Promise<void>((resolve) => {
+      markPaused = resolve
+    })
+    const callTool = vi.fn(async () => 'should not run')
+    const responseProvider = vi.fn<ResponseProvider>(
+      async () =>
+        ({
+          id: 'abort-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-abort',
+                    type: 'function',
+                    function: {
+                      name: 'sensitive_delete',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        }) as ChatCompletion,
+    )
+
+    const engine = createTestMessageEngine({
+      plugins: [
+        ...silentDefaultPlugins,
+        toolPlugin({
+          getTools: async () => [
+            {
+              type: 'function',
+              function: {
+                name: 'sensitive_delete',
+              },
+            },
+          ],
+          callTool,
+          onToolCallStart(toolCall, context) {
+            context.pauseToolCall(toolCall.id)
+            markPaused()
+          },
+        }),
+      ],
+      responseProvider,
+    })
+
+    const turn = engine.sendMessage('delete sensitive data')
+    await paused
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    await engine.abort()
+    await turn
+
+    expect(callTool).not.toHaveBeenCalled()
+    expect(responseProvider).toHaveBeenCalledOnce()
+    expect(engine.getState()).toMatchObject({
+      requestState: 'aborted',
+      isProcessing: false,
+      isPaused: false,
+    })
+    expect(engine.getState().messages[1]).toMatchObject({
+      state: {
+        toolCall: {
+          'call-abort': {
+            status: 'denied',
+          },
+        },
+      },
+    })
+  })
+
+  it('persists paused turn metadata and restores it from reloaded conversation messages', async () => {
+    const values = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+    } satisfies Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>)
+
+    let shouldPause = true
+    const callTool = vi.fn(async () => 'approved after reload')
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody) => {
+      const hasToolResult = requestBody.messages.some((message) => message.role === 'tool')
+
+      if (!hasToolResult) {
+        return {
+          id: 'persisted-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-persisted',
+                    type: 'function',
+                    function: {
+                      name: 'persisted_lookup',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(requestBody.messages.at(-1)).toMatchObject({
+        role: 'tool',
+        tool_call_id: 'call-persisted',
+        content: 'approved after reload',
+      })
+
+      return {
+        id: 'persisted-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'restored and completed',
+            },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const createPausedEngine = (initialMessages: ChatMessage[] = []) =>
+      createTestMessageEngine({
+        initialMessages,
+        plugins: [
+          ...silentDefaultPlugins,
+          toolPlugin({
+            getTools: async () => [
+              {
+                type: 'function',
+                function: { name: 'persisted_lookup' },
+              },
+            ],
+            callTool,
+            onToolCallStart(toolCall, context) {
+              if (shouldPause) {
+                context.pauseToolCall(toolCall.id, { reason: 'reload-check' })
+              }
+            },
+          }),
+        ],
+        responseProvider,
+      })
+
+    try {
+      const firstEngine = createPausedEngine()
+      await firstEngine.sendMessage('persist this turn')
+
+      expect(firstEngine.getState()).toMatchObject({ requestState: 'paused', isPaused: true })
+      expect(values.has('__tiny-robot-turn')).toBe(true)
+      expect(JSON.parse(values.get('__tiny-robot-turn') ?? '{}').turns[0]).not.toHaveProperty('messages')
+
+      shouldPause = false
+      const persistedMessages = JSON.parse(JSON.stringify(firstEngine.getState().messages)) as ChatMessage[]
+      const persistedAssistant = persistedMessages.find((message) => message.role === 'assistant')
+      if (persistedAssistant) {
+        delete persistedAssistant.state
+      }
+
+      const restoredEngine = createPausedEngine(persistedMessages)
+      expect(restoredEngine.getState()).toMatchObject({
+        requestState: 'paused',
+        isPaused: true,
+      })
+      expect(restoredEngine.getState().messages).toHaveLength(3)
+      expect(restoredEngine.getState().messages[1]).toMatchObject({
+        state: {
+          toolCall: {
+            'call-persisted': { status: 'awaiting-approval' },
+          },
+        },
+      })
+
+      await expect(
+        restoredEngine.dispatchCommand(TOOL_RESUME_COMMAND, {
+          toolCallId: 'call-persisted',
+        }),
+      ).resolves.toEqual({
+        status: 'resumed',
+        toolCallId: 'call-persisted',
+      })
+
+      expect(callTool).toHaveBeenCalledOnce()
+      expect(restoredEngine.getState()).toMatchObject({ requestState: 'completed' })
+      expect(restoredEngine.getState().messages.at(-1)).toMatchObject({
+        role: 'assistant',
+        content: 'restored and completed',
+      })
+      expect(values.has('__tiny-robot-turn')).toBe(false)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
 })
diff --git a/packages/kit/src/message/types.ts b/packages/kit/src/message/types.ts
index 5d6149c98..26b389e24 100644
--- a/packages/kit/src/message/types.ts
+++ b/packages/kit/src/message/types.ts
@@ -17,9 +17,25 @@ export type DeepReadonly<T> = T extends (...args: any[]) => any
       : T
 
 // Define different states for the request process
-export type RequestState = 'idle' | 'processing' | 'completed' | 'aborted' | 'error'
+export type RequestState = 'idle' | 'processing' | 'completed' | 'paused' | 'aborted' | 'error'
 export type RequestProcessingState = 'requesting' | 'completing' | string
 
+export interface RequestNextOptions {
+  /**
+   * 标记后续请求是从暂停状态恢复触发的请求。
+   * 设置为 true 时，后续 turn 会触发 `onTurnResume`，不会触发 `onTurnStart`。
+   */
+  resume?: boolean
+}
+
+export type MessagePluginCommandHandler = (
+  payload: unknown,
+  context: BasePluginContext & {
+    appendMessage: (message: ChatMessage | ChatMessage[]) => void
+    requestNext: (options?: RequestNextOptions) => void
+  },
+) => MaybePromise<unknown>
+
 export type ChatMessage<
   Metadata extends object = Record<string, unknown>,
   State extends object = Record<string, unknown>,
@@ -47,6 +63,7 @@ export interface PublicMessageState {
   processingState?: RequestProcessingState
   messages: ChatMessage[]
   isProcessing: boolean
+  isPaused: boolean
 }
 
 export interface InternalMessageState {
@@ -56,10 +73,12 @@ export interface InternalMessageState {
 }
 
 export interface MessageRuntime {
+  turnId: string | null
   currentTurn: ChatMessage[]
   customContext: Record<string, unknown>
   abortController: AbortController | null
   responseProvider: ResponseProvider
+  commandHandlers: Map<string, MessagePluginCommandHandler>
 }
 
 export interface MessageEngine {
@@ -70,6 +89,7 @@ export interface MessageEngine {
   send(...msgs: ChatMessage[]): Promise<void>
   abort(): Promise<void>
   setResponseProvider(provider: ResponseProvider): void
+  dispatchCommand<Result = unknown>(command: string, payload?: unknown): Promise<Result>
 }
 
 export type MessageUpdateKind = 'messages' | 'requestState'
@@ -152,7 +172,7 @@ export interface AfterRequestContext extends BasePluginContext {
    * 使用 appendMessage 函数追加消息，可触发消息更新通知。
    */
   appendMessage: (message: ChatMessage | ChatMessage[]) => void
-  requestNext: () => void
+  requestNext: (options?: RequestNextOptions) => void
 }
 
 export interface CompletionChunkContext extends BasePluginContext {
@@ -182,12 +202,28 @@ export interface MessageEnginePlugin {
    * 按插件注册顺序串行执行，便于做有序初始化/校验；出错则中断流程。
    */
   onTurnStart?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合（turn）从暂停状态恢复后的生命周期钩子。
+   * 与 `onTurnStart` 互斥：resume 触发的后续请求只触发 `onTurnResume`。
+   */
+  onTurnResume?: (context: BasePluginContext) => MaybePromise<void>
   /**
    * 一次对话回合（turn）结束的生命周期钩子。
    * 触发时机：本轮对话完成（成功、被中止）后。
    * 执行策略：按插件注册顺序串行执行，有错误则中断流程。
    */
   onTurnEnd?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合（turn）暂停钩子。
+   * 触发时机：本轮请求进入 `paused` 状态后，例如工具调用等待人工确认。
+   * 与 `onTurnEnd` 互斥：暂停的 turn 只触发 `onTurnPause`，不会触发 `onTurnEnd`。
+   */
+  onTurnPause?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合被外部取消的生命周期钩子。
+   * paused 状态下调用 abort 时也会触发，用于清理等待中的工具调用。
+   */
+  onTurnAbort?: (context: BasePluginContext) => MaybePromise<void>
   /**
    * 请求开始前的生命周期钩子。
    * 触发时机：已组装 requestBody，正式发起请求之前。
@@ -207,10 +243,20 @@ export interface MessageEnginePlugin {
   onCompletionChunk?: (context: CompletionChunkContext) => void
   onError?: (context: BasePluginContext & { error: unknown }) => void
   onFinally?: (context: BasePluginContext) => void
+  /**
+   * 插件命令集合。
+   * 插件可以在这里声明额外的外部命令入口。
+   */
+  commands?: Record<string, MessagePluginCommandHandler>
 }
 
 export interface CreateMessageEngineOptions {
   initialMessages?: ChatMessage[]
+  /**
+   * Automatically persist paused turns in the browser when localStorage is available.
+   * Defaults to true so existing tool pause integrations can survive a page reload.
+   */
+  persistPausedTurn?: boolean
   /**
    * 请求消息时，要包含的字段（白名单）。默认包含所有字段。
    * 如果 `requestMessageFieldsExclude` 存在，会先取 `requestMessageFields` 中的字段，再排除 `requestMessageFieldsExclude` 中的字段
diff --git a/packages/kit/src/skills/test/skillPlugin.test.ts b/packages/kit/src/skills/test/skillPlugin.test.ts
index 9b1f16075..5e3fde1c4 100644
--- a/packages/kit/src/skills/test/skillPlugin.test.ts
+++ b/packages/kit/src/skills/test/skillPlugin.test.ts
@@ -2,7 +2,14 @@ import type { ChatCompletion } from 'openai/resources'
 import { describe, expect, it, vi } from 'vitest'
 import { createNativeMessageAdapter } from '../../message/adapters/native'
 import { createMessageEngine } from '../../message/core/engine'
-import { getSkillRequestContext, lengthPlugin, skillPlugin, thinkingPlugin, toolPlugin } from '../../message/plugins'
+import {
+  getSkillRequestContext,
+  lengthPlugin,
+  skillPlugin,
+  thinkingPlugin,
+  TOOL_RESUME_COMMAND,
+  toolPlugin,
+} from '../../message/plugins'
 import type { SkillPluginOptions, SkillSelection } from '../../message/plugins'
 import type { CreateMessageEngineOptions, MessageRequestBody, ResponseProvider } from '../../message/types'
 import { mockResponseProvider } from '../../message/test/mockResponseProvider'
@@ -165,6 +172,340 @@ describe('skillPlugin', () => {
     })
   })
 
+  it('rebuilds skill runtime tools before resuming a persisted turn', async () => {
+    const values = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+    } satisfies Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>)
+
+    let shouldPause = true
+    const callTool = vi.fn(async () => 'fallback should not run')
+    const skill: SkillDefinition = {
+      name: 'docs',
+      description: 'Docs skill',
+      instructions: 'Use docs.',
+      resources: [
+        {
+          path: 'guide.md',
+          kind: 'text',
+          resourceId: 'guide.md',
+          readText: async () => '# Rebuilt guide',
+        },
+      ],
+    }
+    const getSkillByName = vi.fn(async (name: string) => (name === skill.name ? skill : undefined))
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody: MessageRequestBody) => {
+      const hasToolResult = requestBody.messages.some((message) => message.role === 'tool')
+
+      if (!hasToolResult) {
+        return {
+          id: 'persisted-skill-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-rebuild-skill',
+                    type: 'function',
+                    function: {
+                      name: 'read_skill_file',
+                      arguments: JSON.stringify({ skillName: 'docs', path: 'guide.md' }),
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(String(requestBody.messages.at(-1)?.content)).toContain('Rebuilt guide')
+      return {
+        id: 'persisted-skill-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'rebuild done',
+            },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const createEngine = (initialMessages: CreateMessageEngineOptions['initialMessages'] = []) =>
+      createTestMessageEngine({
+        initialMessages,
+        plugins: [
+          ...silentDefaultPlugins,
+          skillPlugin({
+            selection: { mode: 'manual', skillNames: [skill.name] },
+            getSkillByName,
+          }),
+          toolPlugin({
+            getTools: async () => [],
+            callTool,
+            onToolCallStart(toolCall, context) {
+              if (shouldPause) {
+                context.pauseToolCall(toolCall.id, { reason: 'rebuild-check' })
+              }
+            },
+          }),
+        ],
+        responseProvider,
+      })
+
+    try {
+      const firstEngine = createEngine()
+      await firstEngine.sendMessage('read docs')
+
+      expect(firstEngine.getState()).toMatchObject({ requestState: 'paused', isPaused: true })
+      const snapshot = JSON.parse(values.get('__tiny-robot-turn') ?? '{}')
+      expect(snapshot.turns[0].customContext.__tiny_robot_skill).not.toHaveProperty('runtimeTools')
+
+      shouldPause = false
+      const restoredEngine = createEngine(firstEngine.getState().messages)
+
+      await expect(
+        restoredEngine.dispatchCommand(TOOL_RESUME_COMMAND, {
+          toolCallId: 'call-rebuild-skill',
+        }),
+      ).resolves.toEqual({
+        status: 'resumed',
+        toolCallId: 'call-rebuild-skill',
+      })
+
+      expect(callTool).not.toHaveBeenCalled()
+      expect(getSkillByName).toHaveBeenCalledTimes(2)
+      expect(restoredEngine.getState().messages.at(-1)).toMatchObject({
+        role: 'assistant',
+        content: 'rebuild done',
+      })
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
+  it('rebuilds skill runtime tools when the turn snapshot is unavailable', async () => {
+    const values = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+    } satisfies Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>)
+
+    let shouldPause = true
+    const skill: SkillDefinition = {
+      name: 'docs',
+      description: 'Docs skill',
+      instructions: 'Use docs.',
+      resources: [
+        {
+          path: 'guide.md',
+          kind: 'text',
+          resourceId: 'guide.md',
+          text: '# Rebuilt without snapshot',
+        },
+      ],
+    }
+    const getSkillByName = vi.fn(async (name: string) => (name === skill.name ? skill : undefined))
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody: MessageRequestBody) => {
+      if (!requestBody.messages.some((message) => message.role === 'tool')) {
+        return {
+          id: 'missing-snapshot-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    id: 'call-missing-snapshot',
+                    type: 'function',
+                    function: {
+                      name: 'read_skill_file',
+                      arguments: JSON.stringify({ skillName: 'docs', path: 'guide.md' }),
+                    },
+                  },
+                ],
+              },
+              finish_reason: 'tool_calls',
+            },
+          ],
+        } as ChatCompletion
+      }
+
+      expect(String(requestBody.messages.at(-1)?.content)).toContain('Rebuilt without snapshot')
+      return {
+        id: 'missing-snapshot-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'rebuild done' },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const createEngine = (initialMessages: CreateMessageEngineOptions['initialMessages'] = []) =>
+      createTestMessageEngine({
+        initialMessages,
+        plugins: [
+          ...silentDefaultPlugins,
+          skillPlugin({
+            selection: { mode: 'manual', skillNames: [skill.name] },
+            getSkillByName,
+          }),
+          toolPlugin({
+            getTools: async () => [],
+            callTool: async () => {
+              throw new Error('runtime skill tool was not rebuilt')
+            },
+            onToolCallStart(toolCall, context) {
+              if (shouldPause) {
+                context.pauseToolCall(toolCall.id)
+              }
+            },
+          }),
+        ],
+        responseProvider,
+      })
+
+    try {
+      const firstEngine = createEngine()
+      await firstEngine.sendMessage('read docs')
+      const messages = firstEngine.getState().messages
+      values.delete('__tiny-robot-turn')
+
+      shouldPause = false
+      const restoredEngine = createEngine(messages)
+      await expect(
+        restoredEngine.dispatchCommand(TOOL_RESUME_COMMAND, {
+          toolCallId: 'call-missing-snapshot',
+        }),
+      ).resolves.toMatchObject({ status: 'resumed' })
+
+      expect(getSkillByName).toHaveBeenCalledTimes(2)
+      expect(restoredEngine.getState().messages.at(-1)).toMatchObject({
+        role: 'assistant',
+        content: 'rebuild done',
+      })
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
+  it('rebuilds resource handlers from pending tool arguments when the skill context is missing', async () => {
+    const skill: SkillDefinition = {
+      name: 'docs',
+      description: 'Docs skill',
+      instructions: 'Use docs.',
+      resources: [
+        {
+          path: 'guide.md',
+          kind: 'text',
+          resourceId: 'guide.md',
+          text: '# Rebuilt from pending tool call',
+        },
+      ],
+    }
+    const getSkillByName = vi.fn(async (name: string) => (name === skill.name ? skill : undefined))
+    const responseProvider = vi.fn<ResponseProvider>(async (requestBody: MessageRequestBody) => {
+      expect(String(requestBody.messages.at(-1)?.content)).toContain('Rebuilt from pending tool call')
+      return {
+        id: 'pending-skill-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'rebuild done' },
+            finish_reason: 'stop',
+          },
+        ],
+      } as ChatCompletion
+    })
+
+    const engine = createTestMessageEngine({
+      initialMessages: [
+        { role: 'user', content: 'read docs' },
+        {
+          role: 'assistant',
+          content: '',
+          tool_calls: [
+            {
+              id: 'call-pending-context',
+              type: 'function',
+              function: {
+                name: 'read_skill_file',
+                arguments: JSON.stringify({ skillName: 'docs', path: 'guide.md' }),
+              },
+            },
+          ],
+          state: {
+            toolCall: {
+              'call-pending-context': { status: 'awaiting-approval' },
+            },
+          },
+        },
+        {
+          role: 'tool',
+          tool_call_id: 'call-pending-context',
+          content: 'Tool call awaiting confirmation.',
+        },
+      ],
+      plugins: [
+        ...silentDefaultPlugins,
+        skillPlugin({
+          selection: { mode: 'none' },
+          getSkillByName,
+        }),
+        toolPlugin({
+          getTools: async () => [],
+          callTool: async () => {
+            throw new Error('runtime skill tool was not rebuilt')
+          },
+        }),
+      ],
+      responseProvider,
+    })
+
+    await expect(
+      engine.dispatchCommand(TOOL_RESUME_COMMAND, {
+        toolCallId: 'call-pending-context',
+      }),
+    ).resolves.toMatchObject({ status: 'resumed' })
+
+    expect(getSkillByName).toHaveBeenCalledOnce()
+    expect(engine.getState().messages.at(-1)).toMatchObject({
+      role: 'assistant',
+      content: 'rebuild done',
+    })
+  })
+
   it('calls onInstructionsResolved immediately without a request body', async () => {
     const events: string[] = []
     const responseProvider = vi.fn(mockResponseProvider('ok'))
diff --git a/packages/kit/src/vue/message/plugins/toolPlugin.ts b/packages/kit/src/vue/message/plugins/toolPlugin.ts
index 2bd9dba40..836f54556 100644
--- a/packages/kit/src/vue/message/plugins/toolPlugin.ts
+++ b/packages/kit/src/vue/message/plugins/toolPlugin.ts
@@ -1,17 +1,35 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { toolPlugin as createCoreToolPlugin } from '../../../message/plugins'
-import type { ToolProviderItem, ToolSource } from '../../../message/plugins'
+import type { ToolCallPauseOptions, ToolProviderItem, ToolSource } from '../../../message/plugins'
 import { normalizeToAsyncGenerator } from '../../../message/utils'
 import type { ChatMessage, MaybePromise, MaybeStreamableResult, ToolCall } from '../../../types'
 import type { VueMessagePluginRuntime } from '../types.internal'
 import type { BasePluginContext, UseMessagePlugin } from '../types'
 
+export {
+  TOOL_REJECT_COMMAND,
+  TOOL_REJECT_TURN_COMMAND,
+  TOOL_RESUME_COMMAND,
+  TOOL_RESUME_TURN_COMMAND,
+} from '../../../message/plugins'
+export type {
+  ToolCallPauseOptions,
+  ToolResumeCommandPayload,
+  ToolResumeCommandResult,
+  ToolTurnCommandPayload,
+  ToolTurnCommandResult,
+} from '../../../message/plugins'
+
 export interface UseMessageToolActionContext extends BasePluginContext {
   assistantMessage: ChatMessage
   /**
    * 当前工具的来源。
    */
   toolSource?: ToolSource
+  /**
+   * 在工具正式执行前挂起当前 tool call。
+   */
+  pauseToolCall: (toolCallId: string, options?: ToolCallPauseOptions) => void
   /**
    * @deprecated use `assistantMessage` instead
    */
@@ -28,6 +46,10 @@ export interface UseMessageToolCallContext extends BasePluginContext {
    * 当前工具的来源。
    */
   toolSource: ToolSource
+  /**
+   * 在工具正式执行前挂起当前 tool call。
+   */
+  pauseToolCall: (toolCallId: string, options?: ToolCallPauseOptions) => void
   /**
    * @deprecated use `assistantMessage` instead
    */
@@ -45,6 +67,11 @@ export const toolPlugin = (
      * 在处理包含 tool_calls 的响应前调用。
      */
     beforeCallTools?: (toolCalls: ToolCall[], context: UseMessageToolActionContext) => Promise<void>
+    /**
+     * 在每个工具调用正式执行前判断是否需要等待外部确认。
+     * 返回 true 时当前工具会进入 awaiting-approval，其他工具仍可继续执行。
+     */
+    shouldPauseToolCall?: (toolCall: ToolCall, context: UseMessageToolCallContext) => boolean | Promise<boolean>
     /**
      * 执行单个工具调用并返回其文本结果的函数。
      */
@@ -64,20 +91,28 @@ export const toolPlugin = (
      * 触发时机：工具调用完成（成功、失败或取消）时触发。
      * @param toolCall - 工具调用对象
      * @param context - 插件上下文，包含当前工具消息、状态和错误信息
-     * @param context.status - 工具调用状态：'success' | 'failed' | 'cancelled'
-     * @param context.error - 当状态为 'failed' 或 'cancelled' 时，可能包含错误信息
+     * @param context.status - 工具调用状态：'success' | 'failed' | 'cancelled' | 'denied'
+     * @param context.error - 当状态为 'failed'、'cancelled' 或 'denied' 时，可能包含错误信息
      */
     onToolCallEnd?: (
       toolCall: ToolCall,
       context: UseMessageToolCallContext & {
-        status: 'success' | 'failed' | 'cancelled'
+        status: 'success' | 'failed' | 'cancelled' | 'denied'
         error?: Error
       },
     ) => void
+    /**
+     * 工具调用进入等待确认时使用的消息内容。
+     */
+    toolCallPausedContent?: string
     /**
      * 当请求被中止时用于工具调用取消的消息内容。
      */
     toolCallCancelledContent?: string
+    /**
+     * 工具调用被拒绝时使用的消息内容。
+     */
+    toolCallDeniedContent?: string
     /**
      * 当工具调用执行失败（抛错或拒绝）时使用的消息内容。
      */
@@ -93,10 +128,13 @@ export const toolPlugin = (
   const {
     getTools,
     beforeCallTools,
+    shouldPauseToolCall,
     callTool,
     onToolCallStart,
     onToolCallEnd,
+    toolCallPausedContent,
     toolCallCancelledContent = 'Tool call cancelled.',
+    toolCallDeniedContent = 'Tool call denied.',
     toolCallFailedContent = 'Tool call failed.',
     autoFillMissingToolMessages = false,
     ...restOptions
@@ -118,6 +156,22 @@ export const toolPlugin = (
                 ...runtime.createVueBaseContext(context),
                 assistantMessage,
                 currentMessage: assistantMessage,
+                pauseToolCall: context.pauseToolCall,
+              })
+            }
+          : undefined,
+        shouldPauseToolCall: shouldPauseToolCall
+          ? async (toolCall, context) => {
+              const assistantMessage = runtime.resolveReactiveMessage(context.assistantMessage as ChatMessage)
+              const toolMessage = runtime.resolveReactiveMessage(context.toolMessage as ChatMessage)
+
+              return shouldPauseToolCall(toolCall as unknown as ToolCall, {
+                ...runtime.createVueBaseContext(context),
+                assistantMessage,
+                primaryMessage: assistantMessage,
+                toolMessage,
+                toolSource: context.toolSource,
+                pauseToolCall: context.pauseToolCall,
               })
             }
           : undefined,
@@ -133,6 +187,7 @@ export const toolPlugin = (
               currentMessage: assistantMessage,
               toolMessage,
               toolSource: context.toolSource,
+              pauseToolCall: context.pauseToolCall,
             } as UseMessageCallToolContext,
           )
 
@@ -151,6 +206,7 @@ export const toolPlugin = (
                 primaryMessage: assistantMessage,
                 toolMessage,
                 toolSource: context.toolSource,
+                pauseToolCall: context.pauseToolCall,
               })
             }
           : undefined,
@@ -165,12 +221,15 @@ export const toolPlugin = (
                 primaryMessage: assistantMessage,
                 toolMessage,
                 toolSource: context.toolSource,
+                pauseToolCall: context.pauseToolCall,
                 status: context.status,
                 error: context.error,
               })
             }
           : undefined,
+        toolCallPausedContent,
         toolCallCancelledContent,
+        toolCallDeniedContent,
         toolCallFailedContent,
         autoFillMissingToolMessages,
       })
diff --git a/packages/kit/src/vue/message/types.ts b/packages/kit/src/vue/message/types.ts
index 38da050c1..3d025e98f 100644
--- a/packages/kit/src/vue/message/types.ts
+++ b/packages/kit/src/vue/message/types.ts
@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ComputedRef, Ref } from 'vue'
 import type { AsyncStreamableResult, ChatMessage, MaybePromise, ToolCall } from '../../types'
+import type { RequestNextOptions } from '../../message/types'
 
 export interface Tool {
   type: 'function'
@@ -23,7 +24,7 @@ export interface MessageRequestBody {
 }
 
 // Define different states for the request process
-export type RequestState = 'idle' | 'processing' | 'completed' | 'aborted' | 'error'
+export type RequestState = 'idle' | 'processing' | 'completed' | 'paused' | 'aborted' | 'error'
 export type RequestProcessingState = 'requesting' | 'completing' | string
 
 // Usage information for API response
@@ -82,8 +83,21 @@ export type ResponseProvider<T = ChatCompletion> = (
   abortSignal: AbortSignal,
 ) => AsyncStreamableResult<T>
 
+export type UseMessagePluginCommandHandler = (
+  payload: unknown,
+  context: BasePluginContext & {
+    appendMessage: (message: ChatMessage | ChatMessage[]) => void
+    requestNext: (options?: RequestNextOptions) => void
+  },
+) => MaybePromise<unknown>
+
 export interface UseMessageOptions {
   initialMessages?: ChatMessage[]
+  /**
+   * Automatically persist paused turns in the browser when localStorage is available.
+   * Defaults to true so existing tool pause integrations can survive a page reload.
+   */
+  persistPausedTurn?: boolean
   /**
    * 请求消息时，要包含的字段（白名单）。默认包含所有字段。
    * 如果 `requestMessageFieldsExclude` 存在，会先取 `requestMessageFields` 中的字段，再排除 `requestMessageFieldsExclude` 中的字段
@@ -117,9 +131,11 @@ export interface UseMessageReturn {
   messages: Ref<ChatMessage[]>
   responseProvider: Ref<UseMessageOptions['responseProvider']>
   isProcessing: ComputedRef<boolean>
+  isPaused: ComputedRef<boolean>
   sendMessage: (content: string) => Promise<void>
   send: (...msgs: ChatMessage[]) => Promise<void>
   abortRequest: () => Promise<void>
+  dispatchCommand: <Result = unknown>(command: string, payload?: unknown) => Promise<Result>
 }
 
 export interface BasePluginContext {
@@ -127,6 +143,7 @@ export interface BasePluginContext {
   currentTurn: ChatMessage[]
   requestState: RequestState
   processingState?: RequestProcessingState
+  isPaused: boolean
   plugins: UseMessagePlugin[]
   setRequestState: (state: RequestState, processingState?: RequestProcessingState) => void
   abortSignal: AbortSignal
@@ -154,12 +171,28 @@ export interface UseMessagePlugin {
    * 按插件注册顺序串行执行，便于做有序初始化/校验；出错则中断流程。
    */
   onTurnStart?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合（turn）从暂停状态恢复后的生命周期钩子。
+   * 与 `onTurnStart` 互斥：resume 触发的后续请求只触发 `onTurnResume`。
+   */
+  onTurnResume?: (context: BasePluginContext) => MaybePromise<void>
   /**
    * 一次对话回合（turn）结束的生命周期钩子。
    * 触发时机：本轮对话完成（成功、被中止）后
    * 执行策略：按插件注册顺序串行执行，有错误则中断流程
    */
   onTurnEnd?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合（turn）暂停钩子。
+   * 触发时机：本轮请求进入 `paused` 状态后，例如工具调用等待人工确认。
+   * 与 `onTurnEnd` 互斥：暂停的 turn 只触发 `onTurnPause`，不会触发 `onTurnEnd`。
+   */
+  onTurnPause?: (context: BasePluginContext) => MaybePromise<void>
+  /**
+   * 一次对话回合被外部取消的生命周期钩子。
+   * paused 状态下调用 abort 时也会触发，用于清理等待中的工具调用。
+   */
+  onTurnAbort?: (context: BasePluginContext) => MaybePromise<void>
   /**
    * 请求开始前的生命周期钩子。
    * 触发时机：已组装 requestBody，正式发起请求之前。
@@ -181,7 +214,7 @@ export interface UseMessagePlugin {
       currentMessage: ChatMessage
       lastChoice?: CompletionChoice
       appendMessage: (message: ChatMessage | ChatMessage[]) => void
-      requestNext: () => void
+      requestNext: (options?: RequestNextOptions) => void
     },
   ) => MaybePromise<void>
   /**
@@ -198,4 +231,9 @@ export interface UseMessagePlugin {
   ) => void
   onError?: (context: BasePluginContext & { error: unknown }) => void
   onFinally?: (context: BasePluginContext) => void
+  /**
+   * 插件命令集合。
+   * 插件可以在这里声明额外的外部命令入口。
+   */
+  commands?: Record<string, UseMessagePluginCommandHandler>
 }
diff --git a/packages/kit/src/vue/message/useMessage.test.ts b/packages/kit/src/vue/message/useMessage.test.ts
index 02e7b8d53..3654f61c4 100644
--- a/packages/kit/src/vue/message/useMessage.test.ts
+++ b/packages/kit/src/vue/message/useMessage.test.ts
@@ -5,7 +5,7 @@ import type { ChatMessage } from '../../types'
 import { mockResponseProvider, mockSequentialResponseProvider } from './mockResponseProvider'
 import { lengthPlugin } from './plugins/lengthPlugin'
 import { getSkillRequestContext, skillPlugin } from './plugins/skillPlugin'
-import { toolPlugin } from './plugins/toolPlugin'
+import { TOOL_RESUME_COMMAND, toolPlugin } from './plugins/toolPlugin'
 import type { ResponseProvider } from './types'
 import { useMessage } from './useMessage'
 
@@ -195,6 +195,232 @@ describe('useMessage', () => {
     })
   })
 
+  it('exposes paused tool calls and resumes them through the vue command channel', async () => {
+    let markPaused!: () => void
+    const paused = new Promise<void>((resolve) => {
+      markPaused = resolve
+    })
+    const callTool = vi.fn(async () => 'approved result')
+    const responseProvider: ResponseProvider = async (requestBody) => {
+      const hasToolResult = requestBody.messages.some((message) => message.role === 'tool')
+
+      if (!hasToolResult) {
+        return {
+          id: 'tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          system_fingerprint: null,
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    index: 0,
+                    id: 'call-approval',
+                    type: 'function',
+                    function: {
+                      name: 'sensitive_lookup',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              delta: undefined,
+              logprobs: null,
+              finish_reason: 'tool_calls',
+            },
+          ],
+        }
+      }
+
+      return {
+        id: 'tool-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        system_fingerprint: null,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'done',
+            },
+            delta: undefined,
+            logprobs: null,
+            finish_reason: 'stop',
+          },
+        ],
+      }
+    }
+
+    const engine = useMessage({
+      responseProvider,
+      plugins: [
+        toolPlugin({
+          getTools: async () => [
+            {
+              type: 'function',
+              function: {
+                name: 'sensitive_lookup',
+              },
+            },
+          ],
+          callTool,
+          onToolCallStart(toolCall, context) {
+            context.pauseToolCall(toolCall.id)
+            markPaused()
+          },
+        }),
+      ],
+    })
+
+    const turn = engine.sendMessage('run sensitive lookup')
+    await paused
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(engine.isPaused.value).toBe(true)
+    expect(engine.processingState.value).toBeUndefined()
+    expect(callTool).not.toHaveBeenCalled()
+
+    await engine.dispatchCommand(TOOL_RESUME_COMMAND, {
+      toolCallId: 'call-approval',
+    })
+    await turn
+
+    expect(callTool).toHaveBeenCalledOnce()
+    expect(engine.isPaused.value).toBe(false)
+    expect(engine.messages.value.at(-1)).toMatchObject({
+      role: 'assistant',
+      content: 'done',
+    })
+  })
+
+  it('restores a persisted paused turn with reactive messages after recreating useMessage', async () => {
+    const values = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+    } satisfies Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>)
+
+    let shouldPause = true
+    const callTool = vi.fn(async () => 'vue restored result')
+    const responseProvider: ResponseProvider = async (requestBody) => {
+      if (!requestBody.messages.some((message) => message.role === 'tool')) {
+        return {
+          id: 'vue-persisted-tool-call',
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: 'mock',
+          system_fingerprint: null,
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                  {
+                    index: 0,
+                    id: 'call-vue-persisted',
+                    type: 'function',
+                    function: {
+                      name: 'vue_persisted_lookup',
+                      arguments: '{}',
+                    },
+                  },
+                ],
+              },
+              delta: undefined,
+              logprobs: null,
+              finish_reason: 'tool_calls',
+            },
+          ],
+        }
+      }
+
+      return {
+        id: 'vue-persisted-answer',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'mock',
+        system_fingerprint: null,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'vue restored done',
+            },
+            delta: undefined,
+            logprobs: null,
+            finish_reason: 'stop',
+          },
+        ],
+      }
+    }
+
+    const createEngine = (initialMessages: ChatMessage[] = []) =>
+      useMessage({
+        initialMessages,
+        responseProvider,
+        plugins: [
+          toolPlugin({
+            getTools: async () => [
+              {
+                type: 'function',
+                function: { name: 'vue_persisted_lookup' },
+              },
+            ],
+            callTool,
+            onToolCallStart(toolCall, context) {
+              if (shouldPause) {
+                context.pauseToolCall(toolCall.id)
+              }
+            },
+          }),
+        ],
+      })
+
+    try {
+      const firstEngine = createEngine()
+      await firstEngine.sendMessage('persist vue turn')
+
+      shouldPause = false
+      const persistedMessages = JSON.parse(JSON.stringify(firstEngine.messages.value)) as ChatMessage[]
+      const restoredEngine = createEngine(persistedMessages)
+      expect(restoredEngine.isPaused.value).toBe(true)
+      expect(restoredEngine.messages.value).toHaveLength(3)
+
+      await restoredEngine.dispatchCommand(TOOL_RESUME_COMMAND, {
+        toolCallId: 'call-vue-persisted',
+      })
+
+      expect(callTool).toHaveBeenCalledOnce()
+      expect(restoredEngine.isPaused.value).toBe(false)
+      expect(restoredEngine.messages.value[1]).toMatchObject({
+        state: { toolCall: { 'call-vue-persisted': { status: 'success' } } },
+      })
+      expect(restoredEngine.messages.value[2]).toMatchObject({
+        role: 'tool',
+        tool_call_id: 'call-vue-persisted',
+        content: 'vue restored result',
+      })
+      expect(restoredEngine.messages.value.at(-1)).toMatchObject({
+        role: 'assistant',
+        content: 'vue restored done',
+      })
+      expect(values.has('__tiny-robot-turn')).toBe(false)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
   it('does not inject vue skill instructions by default', async () => {
     const skills = ref<SkillDefinition[]>([
       {
diff --git a/packages/kit/src/vue/message/useMessage.ts b/packages/kit/src/vue/message/useMessage.ts
index cbbcb947b..061435797 100644
--- a/packages/kit/src/vue/message/useMessage.ts
+++ b/packages/kit/src/vue/message/useMessage.ts
@@ -28,6 +28,7 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
     initialMessages = [],
     requestMessageFields = [],
     requestMessageFieldsExclude = ['state', 'metadata', 'loading'],
+    persistPausedTurn,
     plugins = [],
     responseProvider: initialResponseProvider,
     onCompletionChunk,
@@ -47,6 +48,7 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
       currentTurn: context.currentTurn.map((message) => resolveReactiveMessage(message as ChatMessage)),
       requestState: adapter.requestState.value,
       processingState: adapter.processingState.value,
+      isPaused: adapter.isPaused.value,
       plugins,
       setRequestState: context.setRequestState,
       abortSignal: context.abortSignal,
@@ -71,8 +73,12 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
     const {
       name,
       disabled,
+      commands,
       onTurnStart,
       onTurnEnd,
+      onTurnResume,
+      onTurnPause,
+      onTurnAbort,
       onBeforeRequest,
       onAfterRequest,
       onCompletionChunk,
@@ -95,10 +101,36 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
       corePlugin.onTurnStart = (context) => onTurnStart(createVueBaseContext(context))
     }
 
+    if (onTurnResume) {
+      corePlugin.onTurnResume = (context) => onTurnResume(createVueBaseContext(context))
+    }
+
     if (onTurnEnd) {
       corePlugin.onTurnEnd = (context) => onTurnEnd(createVueBaseContext(context))
     }
 
+    if (onTurnPause) {
+      corePlugin.onTurnPause = (context) => onTurnPause(createVueBaseContext(context))
+    }
+
+    if (onTurnAbort) {
+      corePlugin.onTurnAbort = (context) => onTurnAbort(createVueBaseContext(context))
+    }
+
+    if (commands) {
+      corePlugin.commands = Object.fromEntries(
+        Object.entries(commands).map(([commandName, handler]) => [
+          commandName,
+          (payload, context) =>
+            handler(payload, {
+              ...createVueBaseContext(context),
+              appendMessage: context.appendMessage as (message: ChatMessage | ChatMessage[]) => void,
+              requestNext: context.requestNext,
+            }),
+        ]),
+      )
+    }
+
     if (onBeforeRequest) {
       corePlugin.onBeforeRequest = (context: CoreBeforeRequestContext) =>
         onBeforeRequest({
@@ -163,6 +195,7 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
     initialMessages: initialMessages as CoreChatMessage[],
     requestMessageFields,
     requestMessageFieldsExclude,
+    persistPausedTurn,
     responseProvider: initialResponseProvider as CoreResponseProvider,
     onCompletionChunk: onCompletionChunk ? onCompletionChunkHandler : undefined,
     plugins: plugins.map((plugin) => createCorePlugin(plugin)),
@@ -184,8 +217,10 @@ export const useMessage = (options: UseMessageOptions): UseMessageReturn => {
     messages: adapter.messages,
     responseProvider,
     isProcessing: adapter.isProcessing,
+    isPaused: adapter.isPaused,
     sendMessage: engine.sendMessage,
     send: engine.send,
     abortRequest: engine.abort,
+    dispatchCommand: engine.dispatchCommand,
   } as UseMessageReturn
 }