@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1

package/src/bridge/react/usePlatformAgentSessionDrive.tsx

@@ -0,0 +1,729 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import {
+  AgentRunEventType,
+  createIdleLiveTurn,
+  isComposerEnabled,
+  mapAgentMessages,
+  mapApprovalPendingToolCalls,
+  mapRunState,
+  mergeUsageTurn,
+  reduceAgentLiveTurn,
+  withContextWindowUsage,
+  type PlatformAgentRunEventPayload,
+} from '../../agents/runtime/index.js'
+import type {
+  AgentLiveTurn,
+  AgentUiMessage,
+  AgentUiRunState,
+  AgentUiRunUsage,
+  AgentUiToolCall,
+} from '../../components/agents/agentTypes.js'
+import type {
+  PlatformAgentLlmMenuOption,
+  PlatformAgentRunSnapshot,
+  PlatformAgentSessionConfigPatch,
+  PlatformAgentSessionRecord,
+  PlatformAgentSessionScope,
+  PlatformAgentSessionSummary,
+  PlatformAgentSessionToolPolicy,
+} from '../agentTypes.js'
+import { isAgentAutoModelId, DEFAULT_AGENT_HIGH_LEVEL_MODEL_ID } from '../agentModelTiers.js'
+import {
+  getPlatformPreferences,
+  patchPlatformPreferences,
+} from '../preferences.mjs'
+import {
+  advanceAgentSessionPending,
+  approveAgentSessionTools,
+  createAgentSession,
+  deleteAgentSession,
+  interruptAgentSession,
+  listAgentSessions,
+  onAgentRunEvent,
+  readAgentLlmMenuOptions,
+  readAgentSession,
+  rejectAgentSessionTools,
+  sendAgentSessionMessage,
+  updateAgentSession,
+} from '../agents.mjs'
+
+const DEFAULT_SESSION_TITLE = 'New chat'
+
+export interface UsePlatformAgentSessionDriveOptions {
+  /** App slug that owns app-scoped sessions and tool routing. */
+  appSlug: string
+  scope?: PlatformAgentSessionScope
+  enabled?: boolean
+  /**
+   * Bind to one specific session (e.g. an ephemeral thread that lives only while
+   * a modal is open). When set, the hook drives exactly this session and skips
+   * list auto-load and auto-create — the app owns its create/delete lifecycle.
+   */
+  sessionId?: string
+  /** Persisted to session metadata so the shell can restore the bound tab. */
+  restoreTabId?: string
+  /** Create a fresh session when the scope has none. Ignored when `sessionId` is set. Defaults to true. */
+  autoCreate?: boolean
+  rejectReason?: string
+}
+
+export interface UsePlatformAgentSessionDrive {
+  scope: PlatformAgentSessionScope
+  setScope: (scope: PlatformAgentSessionScope) => void
+  sessionRecord: PlatformAgentSessionRecord | null
+  sessionSummaries: PlatformAgentSessionSummary[]
+  sessionId: string | null
+  messages: AgentUiMessage[]
+  liveTurn: AgentLiveTurn
+  pendingToolCalls: AgentUiToolCall[]
+  runState: AgentUiRunState | null
+  busy: boolean
+  error: string | null
+  composerValue: string
+  setComposerValue: (value: string) => void
+  modelId: string
+  setModelId: (modelId: string) => Promise<void>
+  modelOptions: PlatformAgentLlmMenuOption[]
+  modelUnavailableReason: string | null
+  usage: AgentUiRunUsage | null
+  canSend: boolean
+  canInterrupt: boolean
+  interruptRun: (reason?: string) => Promise<void>
+  /** Send the composer value, or an explicit message (programmatic). Returns the final snapshot. */
+  sendMessage: (message?: string) => Promise<PlatformAgentRunSnapshot | null>
+  approveTools: (toolCallIds?: readonly string[]) => Promise<void>
+  approveToolAlwaysForSession: (
+    qualifiedName: string,
+    toolCallId: string,
+  ) => Promise<void>
+  rejectTools: (toolCallIds?: readonly string[]) => Promise<void>
+  selectSession: (sessionId: string) => Promise<void>
+  createNewSession: () => Promise<void>
+  deleteSession: () => Promise<void>
+  renameSession: (title: string) => Promise<void>
+  allowedTargetApps: string[]
+  setAllowedTargetApps: (slugs: readonly string[]) => Promise<void>
+  setToolApprovalOverride: (
+    qualifiedName: string,
+    requiresApproval: boolean,
+  ) => Promise<void>
+  refresh: () => Promise<void>
+}
+
+interface DriveResult {
+  session: PlatformAgentSessionRecord
+  snapshot: PlatformAgentRunSnapshot
+  effectiveToolPolicy?: PlatformAgentSessionToolPolicy
+  manualPendingToolCalls: AgentUiToolCall[]
+}
+
+/** Display snapshot from a persisted session record (before any live run this turn). */
+function recordSnapshot(
+  record: PlatformAgentSessionRecord | null,
+): PlatformAgentRunSnapshot | null {
+  if (!record) return null
+  return {
+    runId: record.runId ?? '',
+    state: record.snapshot.state,
+    turn: record.snapshot.turn,
+    messages: record.snapshot.messages,
+    error: record.snapshot.error,
+    interruptedReason: record.snapshot.interruptedReason,
+  }
+}
+
+function mergeScopeDefaultPatch(
+  base: PlatformAgentSessionConfigPatch | undefined,
+  patch: PlatformAgentSessionConfigPatch,
+): PlatformAgentSessionConfigPatch {
+  const toolPolicy =
+    patch.toolPolicy || base?.toolPolicy
+      ? {
+          ...base?.toolPolicy,
+          ...patch.toolPolicy,
+          approvalOverrides: {
+            ...base?.toolPolicy?.approvalOverrides,
+            ...patch.toolPolicy?.approvalOverrides,
+          },
+        }
+      : undefined
+  return { ...base, ...patch, ...(toolPolicy ? { toolPolicy } : {}) }
+}
+
+export function usePlatformAgentSessionDrive({
+  appSlug,
+  scope: initialScope = 'app',
+  enabled = true,
+  sessionId: boundSessionId,
+  restoreTabId,
+  autoCreate = true,
+  rejectReason,
+}: UsePlatformAgentSessionDriveOptions): UsePlatformAgentSessionDrive {
+  const [scope, setScope] = useState<PlatformAgentSessionScope>(initialScope)
+  const [sessionRecord, setSessionRecord] =
+    useState<PlatformAgentSessionRecord | null>(null)
+  const [sessionSummaries, setSessionSummaries] = useState<
+    PlatformAgentSessionSummary[]
+  >([])
+  const [snapshot, setSnapshot] = useState<PlatformAgentRunSnapshot | null>(
+    null,
+  )
+  const [policy, setPolicy] = useState<
+    PlatformAgentSessionToolPolicy | undefined
+  >(undefined)
+  const [drivePendingToolCalls, setDrivePendingToolCalls] = useState<
+    AgentUiToolCall[] | undefined
+  >(undefined)
+  const [liveTurn, setLiveTurn] = useState<AgentLiveTurn>(createIdleLiveTurn)
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [composerValue, setComposerValue] = useState('')
+  const [optimisticModelId, setOptimisticModelId] = useState<string | null>(
+    null,
+  )
+  const [modelOptions, setModelOptions] = useState<
+    PlatformAgentLlmMenuOption[]
+  >([])
+
+  // one active run per hook instance. Latches runId from the first
+  // forwarded event so first-turn streaming works before the RPC resolves.
+  // Upgrade path: thread an explicit runId if one iframe drives many runs at once.
+  const activeRunIdRef = useRef<string | undefined>(undefined)
+  const stopRequestedRef = useRef(false)
+
+  const scopeAppSlug = scope === 'app' ? appSlug : undefined
+
+  const sessionQuery = useCallback(
+    (sessionId: string) => ({ scope, sessionId, appSlug: scopeAppSlug }),
+    [scope, scopeAppSlug],
+  )
+
+  const refreshSessionList = useCallback(async () => {
+    const listed = await listAgentSessions({ scope, appSlug: scopeAppSlug })
+    setSessionSummaries(listed)
+    return listed
+  }, [scope, scopeAppSlug])
+
+  const adoptRecord = useCallback((record: PlatformAgentSessionRecord) => {
+    setSessionRecord(record)
+    setSnapshot(null)
+    setPolicy(undefined)
+    setDrivePendingToolCalls(undefined)
+    setLiveTurn(createIdleLiveTurn())
+    activeRunIdRef.current = record.runId
+  }, [])
+
+  const applyDriveResult = useCallback((result: DriveResult) => {
+    setSessionRecord(result.session)
+    setSnapshot(result.snapshot)
+    setPolicy(result.effectiveToolPolicy)
+    setDrivePendingToolCalls(result.manualPendingToolCalls)
+    activeRunIdRef.current = result.snapshot.runId
+    setLiveTurn(createIdleLiveTurn())
+  }, [])
+
+  const settlePersistedPending = useCallback(
+    async (record: PlatformAgentSessionRecord) => {
+      if (record.snapshot.state !== 'pending_tools') return
+      const result = await advanceAgentSessionPending({
+        session: sessionQuery(record.sessionId),
+      })
+      if (result) applyDriveResult(result)
+    },
+    [applyDriveResult, sessionQuery],
+  )
+
+  const loadSession = useCallback(async () => {
+    // Bound mode: drive exactly the app-owned session, no list/auto-create.
+    if (boundSessionId) {
+      const record = await readAgentSession(sessionQuery(boundSessionId))
+      adoptRecord(record)
+      await settlePersistedPending(record)
+      return
+    }
+    const listed = await refreshSessionList()
+    const first = listed[0]
+    if (first) {
+      const record = await readAgentSession(sessionQuery(first.sessionId))
+      adoptRecord(record)
+      await settlePersistedPending(record)
+      return
+    }
+    if (!autoCreate) {
+      setSessionRecord(null)
+      return
+    }
+    const created = await createAgentSession({
+      scope,
+      appSlug: scopeAppSlug,
+      title: DEFAULT_SESSION_TITLE,
+      restoreTabId,
+    })
+    adoptRecord(created)
+    await refreshSessionList()
+  }, [
+    adoptRecord,
+    autoCreate,
+    boundSessionId,
+    refreshSessionList,
+    restoreTabId,
+    scope,
+    scopeAppSlug,
+    sessionQuery,
+    settlePersistedPending,
+  ])
+
+  useEffect(() => {
+    if (!enabled) return
+    let cancelled = false
+    void loadSession().catch((cause: unknown) => {
+      if (!cancelled) {
+        setError(cause instanceof Error ? cause.message : String(cause))
+      }
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [enabled, loadSession])
+
+  useEffect(() => {
+    if (!enabled) return
+    let cancelled = false
+    void readAgentLlmMenuOptions({})
+      .then(options => {
+        if (!cancelled) setModelOptions(options)
+      })
+      .catch(() => {
+        if (!cancelled) setModelOptions([])
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [enabled])
+
+  useEffect(() => {
+    setOptimisticModelId(null)
+  }, [sessionRecord?.sessionId])
+
+  // Streaming: persistent listener; latches runId from forwarded events.
+  useEffect(() => {
+    if (!enabled) return
+    let live = createIdleLiveTurn()
+    const unsubscribe = onAgentRunEvent(event => {
+      const payload = event as PlatformAgentRunEventPayload
+      const runId = activeRunIdRef.current
+      if (runId && payload.runId !== runId) return
+      if (!runId) activeRunIdRef.current = payload.runId
+
+      if (
+        payload.type === AgentRunEventType.StateChanged &&
+        'snapshot' in payload
+      ) {
+        setSnapshot({ ...payload.snapshot })
+      }
+      if (payload.type === AgentRunEventType.UsageUpdated) {
+        setSnapshot(current =>
+          current
+            ? {
+                ...current,
+                usage: mergeUsageTurn(
+                  current.usage,
+                  payload.usage,
+                  payload.estimated,
+                ),
+              }
+            : current,
+        )
+      }
+
+      live = reduceAgentLiveTurn(live, payload)
+      setLiveTurn(live)
+    })
+    return unsubscribe
+  }, [enabled, sessionRecord?.sessionId])
+
+  const refresh = useCallback(async () => {
+    if (!sessionRecord) return
+    const record = await readAgentSession(sessionQuery(sessionRecord.sessionId))
+    setSessionRecord(record)
+  }, [sessionQuery, sessionRecord])
+
+  const drive = useCallback(
+    async (
+      run: () => Promise<DriveResult | null>,
+    ): Promise<DriveResult | null> => {
+      if (!enabled || busy) return null
+      setBusy(true)
+      setError(null)
+      try {
+        const result = await run()
+        if (!result) return null
+        applyDriveResult(result)
+        await refreshSessionList()
+        return result
+      } catch (cause) {
+        if (!stopRequestedRef.current) {
+          setError(cause instanceof Error ? cause.message : String(cause))
+        }
+        setLiveTurn(createIdleLiveTurn())
+        return null
+      } finally {
+        stopRequestedRef.current = false
+        setBusy(false)
+      }
+    },
+    [applyDriveResult, busy, enabled, refreshSessionList],
+  )
+
+  const committed = useMemo(
+    () => snapshot ?? recordSnapshot(sessionRecord),
+    [sessionRecord, snapshot],
+  )
+  const displaySnapshot = useMemo(
+    () => recordSnapshot(sessionRecord),
+    [sessionRecord],
+  )
+  const threadSnapshot = useMemo(() => {
+    if (busy && snapshot) return snapshot
+    return committed
+  }, [busy, committed, snapshot])
+  const runState = displaySnapshot ? mapRunState(displaySnapshot.state) : null
+
+  const selectedModelId =
+    optimisticModelId ?? sessionRecord?.config.modelId ?? 'auto'
+
+  const modelUnavailableReason = useMemo(() => {
+    if (isAgentAutoModelId(selectedModelId)) return null
+    if (modelOptions.length === 0) return null
+    const known = modelOptions.some(option => option.value === selectedModelId)
+    return known
+      ? null
+      : 'This model is not available. Check API keys or local runtime in Settings.'
+  }, [modelOptions, selectedModelId])
+
+  const toolPolicy =
+    policy ?? sessionRecord?.config?.toolPolicy ?? undefined
+
+  const pendingToolCalls = useMemo(() => {
+    if (drivePendingToolCalls !== undefined) return drivePendingToolCalls
+    return mapApprovalPendingToolCalls(threadSnapshot, toolPolicy)
+  }, [drivePendingToolCalls, threadSnapshot, toolPolicy])
+  const messages = useMemo(
+    () => mapAgentMessages(threadSnapshot, liveTurn),
+    [liveTurn, threadSnapshot],
+  )
+  const canSend =
+    enabled &&
+    isComposerEnabled(runState, busy) &&
+    !modelUnavailableReason &&
+    composerValue.trim().length > 0
+
+  const canInterrupt = enabled && busy && sessionRecord !== null
+
+  const contextWindowByModelId = useMemo(() => {
+    const map = new Map<string, number>()
+    for (const option of modelOptions) {
+      if (option.contextWindowTokens) {
+        map.set(option.value, option.contextWindowTokens)
+      }
+    }
+    return map
+  }, [modelOptions])
+
+  const usage = useMemo<AgentUiRunUsage | null>(() => {
+    const raw = threadSnapshot?.usage
+    if (!raw) return null
+    if (raw.contextWindowTokens) return raw
+    const modelId =
+      threadSnapshot?.effectiveModelId ??
+      (isAgentAutoModelId(selectedModelId)
+        ? DEFAULT_AGENT_HIGH_LEVEL_MODEL_ID
+        : selectedModelId)
+    return (
+      withContextWindowUsage(raw, contextWindowByModelId.get(modelId)) ?? raw
+    )
+  }, [contextWindowByModelId, selectedModelId, threadSnapshot])
+
+  const sendMessage = useCallback(
+    async (
+      messageOverride?: string,
+    ): Promise<PlatformAgentRunSnapshot | null> => {
+      const message = (messageOverride ?? composerValue).trim()
+      if (!message || !sessionRecord) return null
+      // Composer sends respect canSend; programmatic sends only respect busy.
+      if (messageOverride === undefined && !canSend) return null
+      const result = await drive(async () => {
+        const driven = await sendAgentSessionMessage({
+          session: sessionQuery(sessionRecord.sessionId),
+          message,
+        })
+        if (messageOverride === undefined) setComposerValue('')
+        return driven
+      })
+      return result?.snapshot ?? null
+    },
+    [canSend, composerValue, drive, sessionQuery, sessionRecord],
+  )
+
+  const approveTools = useCallback(
+    async (toolCallIds?: readonly string[]) => {
+      if (!sessionRecord || pendingToolCalls.length === 0) return
+      await drive(async () => {
+        const driven = await approveAgentSessionTools({
+          session: sessionQuery(sessionRecord.sessionId),
+          ...(toolCallIds?.length ? { toolCallIds: [...toolCallIds] } : {}),
+        })
+        return driven
+      })
+    },
+    [drive, pendingToolCalls.length, sessionQuery, sessionRecord],
+  )
+
+  const rejectTools = useCallback(
+    async (toolCallIds?: readonly string[]) => {
+      if (!sessionRecord || pendingToolCalls.length === 0) return
+      await drive(async () =>
+        rejectAgentSessionTools({
+          session: sessionQuery(sessionRecord.sessionId),
+          rejectReason,
+          ...(toolCallIds?.length ? { toolCallIds: [...toolCallIds] } : {}),
+        }),
+      )
+    },
+    [drive, pendingToolCalls.length, rejectReason, sessionQuery, sessionRecord],
+  )
+
+  const interruptRun = useCallback(
+    async (reason?: string) => {
+      if (!enabled || !sessionRecord || !canInterrupt) return
+      stopRequestedRef.current = true
+      setError(null)
+      try {
+        const result = await interruptAgentSession({
+          session: sessionQuery(sessionRecord.sessionId),
+          reason,
+        })
+        applyDriveResult(result)
+        await refreshSessionList()
+      } catch (cause) {
+        if (!stopRequestedRef.current) {
+          setError(cause instanceof Error ? cause.message : String(cause))
+        }
+      } finally {
+        stopRequestedRef.current = false
+        setBusy(false)
+      }
+    },
+    [applyDriveResult, canInterrupt, enabled, refreshSessionList, sessionQuery, sessionRecord],
+  )
+
+  const selectSession = useCallback(
+    async (sessionId: string) => {
+      const record = await readAgentSession(sessionQuery(sessionId))
+      adoptRecord(record)
+      setComposerValue('')
+      setError(null)
+      await settlePersistedPending(record)
+    },
+    [adoptRecord, sessionQuery, settlePersistedPending],
+  )
+
+  const createNewSession = useCallback(async () => {
+    const created = await createAgentSession({
+      scope,
+      appSlug: scopeAppSlug,
+      title: DEFAULT_SESSION_TITLE,
+      restoreTabId,
+    })
+    adoptRecord(created)
+    setComposerValue('')
+    await refreshSessionList()
+  }, [adoptRecord, refreshSessionList, restoreTabId, scope, scopeAppSlug])
+
+  const deleteSession = useCallback(async () => {
+    if (!sessionRecord) return
+    await deleteAgentSession(sessionQuery(sessionRecord.sessionId))
+    const listed = await refreshSessionList()
+    const next = listed[0]
+    if (next) {
+      await selectSession(next.sessionId)
+      return
+    }
+    if (autoCreate) await createNewSession()
+    else setSessionRecord(null)
+  }, [
+    autoCreate,
+    createNewSession,
+    refreshSessionList,
+    selectSession,
+    sessionQuery,
+    sessionRecord,
+  ])
+
+  const renameSession = useCallback(
+    async (title: string) => {
+      if (!sessionRecord) return
+      const trimmed = title.trim()
+      if (!trimmed) return
+      const updated = await updateAgentSession({
+        query: sessionQuery(sessionRecord.sessionId),
+        patch: { metadata: { title: trimmed } },
+      })
+      setSessionRecord(updated)
+      await refreshSessionList()
+    },
+    [refreshSessionList, sessionQuery, sessionRecord],
+  )
+
+  const persistScopeDefault = useCallback(
+    async (patch: PlatformAgentSessionConfigPatch) => {
+      try {
+        const prefs = (await getPlatformPreferences()) as {
+          agentSessionDefaults?: {
+            global?: PlatformAgentSessionConfigPatch
+            apps?: Record<string, PlatformAgentSessionConfigPatch>
+          }
+        }
+        const stored = prefs.agentSessionDefaults ?? {}
+        if (scope === 'global') {
+          await patchPlatformPreferences({
+            agentSessionDefaults: {
+              ...stored,
+              global: mergeScopeDefaultPatch(stored.global, patch),
+            },
+          })
+          return
+        }
+        if (!scopeAppSlug) return
+        const apps = { ...(stored.apps ?? {}) }
+        apps[scopeAppSlug] = mergeScopeDefaultPatch(apps[scopeAppSlug], patch)
+        await patchPlatformPreferences({
+          agentSessionDefaults: { ...stored, apps },
+        })
+      } catch {
+        /* scope defaults are best-effort */
+      }
+    },
+    [scope, scopeAppSlug],
+  )
+
+  const setModelId = useCallback(
+    async (modelId: string) => {
+      if (!sessionRecord) return
+      setOptimisticModelId(modelId)
+      try {
+        const updated = await updateAgentSession({
+          query: sessionQuery(sessionRecord.sessionId),
+          patch: { config: { modelId } },
+        })
+        setSessionRecord(updated)
+        setOptimisticModelId(null)
+        await persistScopeDefault({ modelId })
+      } catch (cause) {
+        setOptimisticModelId(null)
+        setError(cause instanceof Error ? cause.message : String(cause))
+      }
+    },
+    [persistScopeDefault, sessionQuery, sessionRecord],
+  )
+
+  const allowedTargetApps =
+    sessionRecord?.config.toolPolicy?.allowedTargetApps ?? []
+
+  const setAllowedTargetApps = useCallback(
+    async (slugs: readonly string[]) => {
+      if (!sessionRecord) return
+      const normalized = [
+        ...new Set(slugs.map(slug => slug.trim()).filter(Boolean)),
+      ]
+      const updated = await updateAgentSession({
+        query: sessionQuery(sessionRecord.sessionId),
+        patch: { config: { toolPolicy: { allowedTargetApps: normalized } } },
+      })
+      setSessionRecord(updated)
+      await persistScopeDefault({
+        toolPolicy: { allowedTargetApps: normalized },
+      })
+    },
+    [persistScopeDefault, sessionQuery, sessionRecord],
+  )
+
+  const setToolApprovalOverride = useCallback(
+    async (qualifiedName: string, requiresApproval: boolean) => {
+      if (!sessionRecord) return
+      const overrides = {
+        ...sessionRecord.config.toolPolicy?.approvalOverrides,
+        [qualifiedName]: requiresApproval,
+      }
+      const updated = await updateAgentSession({
+        query: sessionQuery(sessionRecord.sessionId),
+        patch: { config: { toolPolicy: { approvalOverrides: overrides } } },
+      })
+      setSessionRecord(updated)
+      await persistScopeDefault({
+        toolPolicy: { approvalOverrides: overrides },
+      })
+    },
+    [persistScopeDefault, sessionQuery, sessionRecord],
+  )
+
+  const approveToolAlwaysForSession = useCallback(
+    async (qualifiedName: string, toolCallId: string) => {
+      if (!sessionRecord) return
+      await drive(async () => {
+        const overrides = {
+          ...sessionRecord.config.toolPolicy?.approvalOverrides,
+          [qualifiedName]: false,
+        }
+        const updated = await updateAgentSession({
+          query: sessionQuery(sessionRecord.sessionId),
+          patch: { config: { toolPolicy: { approvalOverrides: overrides } } },
+        })
+        await persistScopeDefault({
+          toolPolicy: { approvalOverrides: overrides },
+        })
+        return approveAgentSessionTools({
+          session: sessionQuery(updated.sessionId),
+          toolCallIds: [toolCallId],
+        })
+      })
+    },
+    [drive, persistScopeDefault, sessionQuery, sessionRecord],
+  )
+
+  return {
+    scope,
+    setScope,
+    sessionRecord,
+    sessionSummaries,
+    sessionId: sessionRecord?.sessionId ?? null,
+    messages,
+    liveTurn,
+    pendingToolCalls,
+    runState,
+    busy,
+    error,
+    composerValue,
+    setComposerValue,
+    modelId: selectedModelId,
+    setModelId,
+    modelOptions,
+    modelUnavailableReason,
+    usage,
+    canSend,
+    canInterrupt,
+    sendMessage,
+    interruptRun,
+    approveTools,
+    approveToolAlwaysForSession,
+    rejectTools,
+    selectSession,
+    createNewSession,
+    deleteSession,
+    renameSession,
+    allowedTargetApps,
+    setAllowedTargetApps,
+    setToolApprovalOverride,
+    refresh,
+  }
+}