@flamingo-stack/openframe-frontend-core 0.0.219 → 0.0.220-snapshot.20260602172647

package/src/components/chat/guide-mode-banner.tsx

@@ -0,0 +1,75 @@
+'use client'
+
+import * as React from 'react'
+import { cn } from '../../utils/cn'
+import { CompassIcon } from '../icons-v2-generated/map-and-travel/compass-icon'
+import { QuestionCircleIcon } from '../icons-v2-generated/signs-and-symbols/question-circle-icon'
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from '../ui/tooltip'
+
+const DEFAULT_LABEL = 'Guide Mode Chat'
+
+const DEFAULT_TOOLTIP =
+  'A quick session chat for exploring OpenFrame. Mingo answers how-to ' +
+  'questions and guides you through configuration, but won’t touch devices, ' +
+  'run scripts, or perform any actions.'
+
+export interface GuideModeBannerProps {
+  /** Banner label (uppercased by the `text-h5` style). */
+  label?: React.ReactNode
+  /** Help-icon tooltip copy. `null` hides the help icon entirely. */
+  tooltip?: React.ReactNode | null
+  className?: string
+}
+
+/**
+ * Guide-mode indicator banner — Figma node `7532:328222`. A full-bleed accent
+ * (yellow) strip below the chat header: leading compass icon, the "Guide Mode
+ * Chat" label, and a trailing help icon whose tooltip explains the temporary,
+ * read-only nature of Guide mode.
+ */
+export function GuideModeBanner({
+  label = DEFAULT_LABEL,
+  tooltip = DEFAULT_TOOLTIP,
+  className,
+}: GuideModeBannerProps) {
+  return (
+    <div
+      className={cn(
+        'flex h-8 w-full shrink-0 items-center gap-[var(--spacing-system-xs)] bg-ods-accent px-[var(--spacing-system-m)] py-[var(--spacing-system-xsf)]',
+        className,
+      )}
+    >
+      <CompassIcon size={16} className="shrink-0 text-ods-text-on-accent" />
+      <p className="flex-1 truncate text-h5 uppercase text-ods-text-on-accent">
+        {label}
+      </p>
+      {tooltip != null && (
+        <TooltipProvider delayDuration={0}>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                type="button"
+                aria-label="About Guide Mode"
+                className="shrink-0 rounded-sm text-ods-text-on-accent focus:outline-none focus-visible:ring-2 focus-visible:ring-ods-text-on-accent"
+              >
+                <QuestionCircleIcon size={16} />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent
+              side="bottom"
+              align="end"
+              className="max-w-[280px] text-h6 normal-case"
+            >
+              {tooltip}
+            </TooltipContent>
+          </Tooltip>
+        </TooltipProvider>
+      )}
+    </div>
+  )
+}

package/src/components/chat/guide-welcome.tsx

@@ -0,0 +1,199 @@
+'use client'
+
+import * as React from 'react'
+import { cn } from '../../utils/cn'
+import { MingoIcon } from '../icons'
+import { Tag } from '../ui/tag'
+import { MoreActionsMenu } from '../ui/more-actions-menu'
+import { Ellipsis01Icon } from '../icons-v2-generated'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/** A guide quick-action chip (e.g. "How to start"). */
+export interface GuideQuickAction {
+  /** Stable React key. */
+  id: string
+  /** Chip label. */
+  label: string
+  /** Prompt text seeded into the composer on click. Defaults to `label`. */
+  prompt?: string
+}
+
+export interface GuideWelcomeProps {
+  /** Greeting heading. Defaults to "Guide Mode Chat". */
+  title?: React.ReactNode
+  /** Greeting sub-line. Defaults to the OpenFrame temporary-session copy. */
+  subtitle?: React.ReactNode
+  /** Quick-action chips — caller-provided; there are no built-in defaults, so
+   *  the chip row is omitted entirely unless the host supplies actions. The
+   *  first `maxVisibleQuickActions` render inline; the rest collapse under a
+   *  trailing "⋯" overflow menu. */
+  quickActions?: ReadonlyArray<GuideQuickAction>
+  /** How many chips to show inline before overflowing to the menu (default 3). */
+  maxVisibleQuickActions?: number
+  /** Fired when a quick-action chip (inline or menu) is activated. */
+  onQuickAction?: (action: GuideQuickAction) => void
+  /** Slash-command onboarding list — rendered inside the shared scroll region
+   *  below the greeting (so greeting + list scroll together, with edge fades). */
+  children?: React.ReactNode
+  className?: string
+}
+
+// =============================================================================
+// Defaults (OpenFrame copy — overridable; the kit stays platform-agnostic)
+// =============================================================================
+
+const DEFAULT_TITLE = 'Guide Mode Chat'
+
+const DEFAULT_SUBTITLE =
+  'This chat is temporary and will not be saved. Ask about OpenFrame docs, ' +
+  'known issues, or manage your support tickets right here.'
+
+// =============================================================================
+// Component
+// =============================================================================
+
+/**
+ * GuideWelcome — Figma node `7532:328214`.
+ *
+ * Guide-mode chat empty state: a centred greeting and the slash-command
+ * onboarding list share one scroll region (with top/bottom fade affordances),
+ * and a pinned quick-action chip row sits above the composer. The first few
+ * quick actions render as chips; the remainder collapse under a "⋯" menu.
+ *
+ * Mirrors `MingoWelcome` (the default-mode empty state) — content is
+ * configurable with OpenFrame defaults.
+ */
+export function GuideWelcome({
+  title = DEFAULT_TITLE,
+  subtitle = DEFAULT_SUBTITLE,
+  quickActions = [],
+  maxVisibleQuickActions = 3,
+  onQuickAction,
+  children,
+  className,
+}: GuideWelcomeProps) {
+  // Scroll-fade affordances: a 48px gradient at the top/bottom edge of the
+  // scroll region, shown only while content is actually hidden in that
+  // direction. (Same behaviour as MingoWelcome.)
+  const scrollRef = React.useRef<HTMLDivElement>(null)
+  const [scrollFade, setScrollFade] = React.useState({ top: false, bottom: false })
+  const updateScrollFade = React.useCallback(() => {
+    const el = scrollRef.current
+    if (!el) return
+    const top = el.scrollTop > 1
+    const bottom = el.scrollTop + el.clientHeight < el.scrollHeight - 1
+    setScrollFade((prev) =>
+      prev.top === top && prev.bottom === bottom ? prev : { top, bottom },
+    )
+  }, [])
+  React.useEffect(() => {
+    updateScrollFade()
+    const el = scrollRef.current
+    if (!el || typeof ResizeObserver === 'undefined') return
+    const ro = new ResizeObserver(updateScrollFade)
+    ro.observe(el)
+    return () => ro.disconnect()
+  }, [updateScrollFade])
+
+  const visibleActions = quickActions.slice(0, maxVisibleQuickActions)
+  const overflowActions = quickActions.slice(maxVisibleQuickActions)
+
+  return (
+    <div
+      className={cn(
+        'flex flex-1 min-h-0 flex-col gap-[var(--spacing-system-m)]',
+        className,
+      )}
+    >
+      {/* Greeting + slash-command list share one scroll region; `relative` so
+          the edge fades can overlay it. */}
+      <div className="relative flex flex-1 min-h-0 flex-col">
+        <div
+          ref={scrollRef}
+          onScroll={updateScrollFade}
+          className="flex flex-1 min-h-0 flex-col gap-[var(--spacing-system-m)] overflow-y-auto"
+        >
+          {/* Greeting grows to fill (`flex-1`) so it centres vertically while
+              the list stays anchored below it. */}
+          <div className="flex flex-1 flex-col items-center justify-center gap-[var(--spacing-system-l)] px-[var(--spacing-system-l)] py-[var(--spacing-system-xxl)] text-center">
+            <MingoIcon
+              className="h-12 w-12"
+              color="white"
+              eyesColor="var(--ods-flamingo-cyan-base)"
+              cornerColor="var(--ods-flamingo-cyan-base)"
+            />
+            <div className="flex w-full flex-col gap-1">
+              <p className="text-h4 text-ods-text-primary">{title}</p>
+              <p className="text-h6 text-ods-text-secondary">{subtitle}</p>
+            </div>
+          </div>
+
+          {children}
+        </div>
+
+        {/* Top scroll-fade — visible only when content is hidden above. */}
+        <div
+          aria-hidden
+          className={cn(
+            'pointer-events-none absolute inset-x-0 top-0 h-12 transition-opacity duration-150',
+            scrollFade.top ? 'opacity-100' : 'opacity-0',
+          )}
+          style={{
+            background:
+              'linear-gradient(0deg, transparent 0%, var(--color-bg) 100%)',
+          }}
+        />
+        {/* Bottom scroll-fade — visible only when content is hidden below. */}
+        <div
+          aria-hidden
+          className={cn(
+            'pointer-events-none absolute inset-x-0 bottom-0 h-12 transition-opacity duration-150',
+            scrollFade.bottom ? 'opacity-100' : 'opacity-0',
+          )}
+          style={{
+            background:
+              'linear-gradient(180deg, transparent 0%, var(--color-bg) 100%)',
+          }}
+        />
+      </div>
+
+      {/* Pinned quick-action chips — always visible above the composer. */}
+      {quickActions.length > 0 && (
+        <div className="flex shrink-0 flex-wrap items-center gap-1">
+          {visibleActions.map((action) => (
+            <button
+              key={action.id}
+              type="button"
+              onClick={() => onQuickAction?.(action)}
+              className="rounded-md focus:outline-none focus-visible:ring-2 focus-visible:ring-ods-accent"
+            >
+              <Tag variant="outline" label={action.label} />
+            </button>
+          ))}
+          {overflowActions.length > 0 && (
+            <MoreActionsMenu
+              ariaLabel="More quick actions"
+              onCloseAutoFocus={(e) => e.preventDefault()}
+              items={overflowActions.map((action) => ({
+                label: action.label,
+                onClick: () => onQuickAction?.(action),
+              }))}
+              trigger={
+                <button
+                  type="button"
+                  aria-label="More quick actions"
+                  className="rounded-md focus:outline-none focus-visible:ring-2 focus-visible:ring-ods-accent"
+                >
+                  <Tag variant="outline" label={<Ellipsis01Icon size={16} />} />
+                </button>
+              }
+            />
+          )}
+        </div>
+      )}
+    </div>
+  )
+}

package/src/components/chat/hooks/use-chat-dialog-manager.ts

@@ -0,0 +1,227 @@
+'use client'
+
+import { useCallback, useMemo, useState } from 'react'
+import type { DialogItem } from '../types/component.types'
+import type {
+  FetchDialogsParams,
+  FetchDialogsResult,
+} from './use-nats-chat-adapter'
+
+export interface UseChatDialogManagerArgs {
+  /** Active (non-archived) dialogs from the unified chat state. */
+  dialogs: ReadonlyArray<DialogItem>
+  /** Currently-open dialog id. */
+  activeDialogId: string | null | undefined
+  /** Open a dialog by id. */
+  selectDialog: (id: string | null) => void
+  /** Reset the open conversation (drops back to the list / empty state). */
+  clearMessages: () => void
+  /** Rename a dialog (wired through the active adapter). */
+  renameDialog: (id: string, title: string) => Promise<void>
+  /** Archive a dialog (wired through the active adapter). */
+  archiveDialog: (id: string) => Promise<void>
+  /** Host callback that pages archived dialogs — gates the archive UI. */
+  fetchArchivedDialogs?: (
+    params: FetchDialogsParams,
+  ) => Promise<FetchDialogsResult>
+  /** Host callback that restores an archived dialog — gates the restore UI. */
+  unarchiveDialog?: (id: string) => Promise<void>
+}
+
+/**
+ * Owns the chat panel's dialog-history concerns so `EmbeddableChat` stays an
+ * orchestrator rather than a state dump:
+ *   - the Chat Archive page (open / paginate the archived list),
+ *   - read-only "archived conversation" mode (open from the archive, restore,
+ *     back-to-archive navigation),
+ *   - the Rename / Archive / Unarchive confirmation-modal targets + handlers.
+ *
+ * Returns flat fields (intentionally the same names the JSX already uses) so
+ * the consuming component reads as a thin wiring layer.
+ */
+export function useChatDialogManager({
+  dialogs,
+  activeDialogId,
+  selectDialog,
+  clearMessages,
+  renameDialog,
+  archiveDialog,
+  fetchArchivedDialogs,
+  unarchiveDialog,
+}: UseChatDialogManagerArgs) {
+  // ─── Rename / Archive confirmation modals ───
+  const [renameTarget, setRenameTarget] = useState<DialogItem | null>(null)
+  const [archiveTarget, setArchiveTarget] = useState<DialogItem | null>(null)
+  const handleConfirmRename = useCallback(
+    (name: string) => {
+      if (renameTarget) void renameDialog(renameTarget.id, name)
+      setRenameTarget(null)
+    },
+    [renameTarget, renameDialog],
+  )
+  const handleConfirmArchive = useCallback(async () => {
+    if (archiveTarget) {
+      try {
+        await archiveDialog(archiveTarget.id)
+      } catch (err) {
+        // Keep the modal open (don't clear the target) so the user can retry;
+        // don't tear down the open conversation for an archive that failed.
+        console.error('[useChatDialogManager] archive failed:', err)
+        return
+      }
+      // Archiving the open conversation drops back to the chat list.
+      if (archiveTarget.id === activeDialogId) {
+        setOpeningDialogId(null)
+        clearMessages()
+      }
+    }
+    setArchiveTarget(null)
+  }, [archiveTarget, archiveDialog, activeDialogId, clearMessages])
+
+  // ─── Chat Archive page ───
+  // The archived list is paged locally (it's a secondary, on-demand view).
+  const [archiveOpen, setArchiveOpen] = useState(false)
+  const [archivedDialogs, setArchivedDialogs] = useState<DialogItem[]>([])
+  const [archivedCursor, setArchivedCursor] = useState<string | null>(null)
+  const [archivedLoading, setArchivedLoading] = useState(false)
+  const loadArchivedPage = useCallback(
+    async (cursor?: string): Promise<void> => {
+      if (!fetchArchivedDialogs) return
+      setArchivedLoading(true)
+      try {
+        const result = await fetchArchivedDialogs({ cursor, limit: 20 })
+        setArchivedCursor(result.nextCursor)
+        setArchivedDialogs((prev) =>
+          cursor ? [...prev, ...result.dialogs] : result.dialogs,
+        )
+      } catch (err) {
+        console.error('[useChatDialogManager] fetchArchivedDialogs failed:', err)
+      } finally {
+        setArchivedLoading(false)
+      }
+    },
+    [fetchArchivedDialogs],
+  )
+  const openArchive = useCallback(() => {
+    setArchiveOpen(true)
+    setArchivedDialogs([])
+    setArchivedCursor(null)
+    void loadArchivedPage()
+  }, [loadArchivedPage])
+  const closeArchive = useCallback(() => setArchiveOpen(false), [])
+
+  // ─── Read-only "archived conversation" mode ───
+  // Set when a chat is opened FROM the archive page — flips the open
+  // conversation into read-only mode (restore button + disabled composer).
+  const [viewingArchivedId, setViewingArchivedId] = useState<string | null>(
+    null,
+  )
+
+  // ─── Open-conversation tracking ───
+  // `openingDialogId` is set synchronously the moment a dialog is selected from
+  // the current-chats list, so the panel can flip to the conversation surface
+  // immediately — matching the archived-chat open (`viewingArchivedId` above)
+  // instead of waiting for `messages` to finish loading. Without it the normal
+  // open lagged behind the archived one (grey → load → flip vs. instant flip).
+  const [openingDialogId, setOpeningDialogId] = useState<string | null>(null)
+  const handleSelectDialog = useCallback(
+    (id: string) => {
+      setViewingArchivedId(null)
+      setOpeningDialogId(id)
+      selectDialog(id)
+    },
+    [selectDialog],
+  )
+  const isOpeningDialog =
+    openingDialogId != null && openingDialogId === activeDialogId
+
+  const handleArchivedSelect = useCallback(
+    (id: string) => {
+      setArchiveOpen(false)
+      setOpeningDialogId(null)
+      setViewingArchivedId(id)
+      selectDialog(id)
+    },
+    [selectDialog],
+  )
+  const [restoreTarget, setRestoreTarget] = useState<DialogItem | null>(null)
+  const handleConfirmRestore = useCallback(async () => {
+    if (restoreTarget) {
+      try {
+        await unarchiveDialog?.(restoreTarget.id)
+      } catch (err) {
+        // Backend restore failed — leave the local archived cache untouched so
+        // the dialog doesn't vanish from the archive only to resurface on the
+        // next fetch. Keep the modal open for a retry.
+        console.error('[useChatDialogManager] unarchive failed:', err)
+        return
+      }
+      // Drop it from the locally-cached archived list and exit read-only mode
+      // so the composer returns and the user can keep chatting.
+      setArchivedDialogs((prev) => prev.filter((d) => d.id !== restoreTarget.id))
+      setViewingArchivedId((cur) => (cur === restoreTarget.id ? null : cur))
+    }
+    setRestoreTarget(null)
+  }, [restoreTarget, unarchiveDialog])
+
+  const isViewingArchived =
+    viewingArchivedId != null && viewingArchivedId === activeDialogId
+
+  // Header back-chevron: from an archived chat, return to the Chat Archive
+  // page (not the current-chats list); otherwise reset to the list.
+  const handleBack = useCallback(() => {
+    const wasArchived = isViewingArchived
+    setViewingArchivedId(null)
+    setOpeningDialogId(null)
+    // Reset the adapter's active dialog id (not just the message buffer):
+    // `clearMessages` empties `messages` but leaves `activeDialogId` pointing at
+    // the just-closed dialog, so re-selecting that same dialog from the list is
+    // a no-op the history-load effect skips → a blank conversation. Selecting
+    // `null` lets the next selection register as a real change and reload.
+    selectDialog(null)
+    clearMessages()
+    if (wasArchived) setArchiveOpen(true)
+  }, [isViewingArchived, selectDialog, clearMessages])
+
+  // Active-conversation dialog — resolved from the active list, or the
+  // archived list when an archived chat is open (archived dialogs aren't in
+  // `dialogs`, so the header title and ⋯ / restore actions need this).
+  const activeDialog = useMemo(
+    () =>
+      dialogs.find((d) => d.id === activeDialogId) ??
+      archivedDialogs.find((d) => d.id === activeDialogId),
+    [dialogs, archivedDialogs, activeDialogId],
+  )
+
+  return {
+    // capability passthroughs (gate the archive / restore affordances)
+    fetchArchivedDialogs,
+    unarchiveDialog,
+    // archive page
+    archiveOpen,
+    archivedDialogs,
+    archivedCursor,
+    archivedLoading,
+    openArchive,
+    closeArchive,
+    loadArchivedPage,
+    handleArchivedSelect,
+    // open conversation (current-chats list)
+    handleSelectDialog,
+    isOpeningDialog,
+    // archived conversation
+    isViewingArchived,
+    handleBack,
+    activeDialog,
+    // action modals
+    renameTarget,
+    setRenameTarget,
+    archiveTarget,
+    setArchiveTarget,
+    restoreTarget,
+    setRestoreTarget,
+    handleConfirmRename,
+    handleConfirmArchive,
+    handleConfirmRestore,
+  }
+}

package/src/components/chat/hooks/use-nats-chat-adapter.ts

@@ -191,6 +191,19 @@ export interface UseNatsChatAdapterConfig {
    */
   fetchChunks?: FetchChunksFunction
 
+  /**
+   * NATS topics to live-tail for the active dialog. Each maps to the
+   * subject suffix `chat.{dialogId}.{topic}` (see
+   * `useNatsDialogSubscription`). Defaults to `['message']` — the
+   * client-chat subject the Tauri Fae Chat consumer relies on. Admin /
+   * Mingo chat publishes its agent replies on `'admin-message'`, so the
+   * openframe EmbeddableChat host MUST set `topics: ['admin-message']`
+   * here — otherwise the subscription tails the wrong subject, no reply
+   * chunks ever arrive, and the assistant placeholder hangs forever in
+   * the `thinking` phase.
+   */
+  topics?: NatsMessageType[]
+
   /**
    * Whether THINKING chunks are surfaced as segments. Default `false`
    * (parity with the existing `useRealtimeChunkProcessor` default).
@@ -241,6 +254,25 @@ export interface UseNatsChatAdapterConfig {
    *  delete affordance is hidden. */
   deleteDialog?: (dialogId: string) => Promise<void>
 
+  /** Rename a dialog on the backend. When omitted, the "Rename" affordance
+   *  in the chat-history row menu is hidden. */
+  renameDialog?: (dialogId: string, title: string) => Promise<void>
+
+  /** Archive a dialog on the backend (removes it from the active list).
+   *  When omitted, the "Archive" affordance in the row menu is hidden. */
+  archiveDialog?: (dialogId: string) => Promise<void>
+
+  /** Fetch a paginated page of ARCHIVED dialogs for the Chat Archive page.
+   *  When omitted, the archive (clock-history) button in the header is
+   *  hidden. Same page/cursor contract as `fetchDialogs`. */
+  fetchArchivedDialogs?: (
+    params: FetchDialogsParams,
+  ) => Promise<FetchDialogsResult>
+
+  /** Restore an archived dialog back to the active list. When omitted, the
+   *  restore (refresh) button in an archived chat's header is hidden. */
+  unarchiveDialog?: (dialogId: string) => Promise<void>
+
   /**
    * Approve a pending tool-call request. Wired into the segment
    * accumulator's `onApprove` so approval-card buttons fire this
@@ -383,12 +415,15 @@ export function useNatsChatAdapter(
     clientConfig,
     publishUserMessage,
     fetchChunks,
+    topics,
     enableThinking,
     batchApprovalsEnabled,
     fetchDialogs,
     fetchDialogMessages,
     createDialog: createDialogCallback,
     deleteDialog: deleteDialogCallback,
+    renameDialog: renameDialogCallback,
+    archiveDialog: archiveDialogCallback,
     approveRequest: approveRequestCallback,
     rejectRequest: rejectRequestCallback,
     stopGeneration: stopGenerationCallback,
@@ -676,6 +711,10 @@ export function useNatsChatAdapter(
   useNatsDialogSubscription({
     enabled: active && dialogId != null,
     dialogId,
+    // Subject suffix to tail. Omitted → the hook defaults to `['message']`
+    // (client chat). Admin/Mingo hosts pass `['admin-message']` so the
+    // live tail lands on the subject the agent actually publishes to.
+    ...(topics ? { topics } : {}),
     getNatsWsUrl,
     clientConfig,
     onEvent: (payload: unknown, messageType: NatsMessageType) => {
@@ -844,6 +883,48 @@ export function useNatsChatAdapter(
     [deleteDialogCallback, internalDialogId, isManagedMode],
   )
 
+  const renameDialog = useCallback(
+    async (id: string, title: string): Promise<void> => {
+      if (!renameDialogCallback) return
+      // Optimistic — update the local title immediately, roll back on error.
+      let previous: string | undefined
+      setDialogs((prev) =>
+        prev.map((d) => {
+          if (d.id !== id) return d
+          previous = d.title
+          return { ...d, title }
+        }),
+      )
+      try {
+        await renameDialogCallback(id, title)
+      } catch (err) {
+        console.error('[useNatsChatAdapter] renameDialog failed:', err)
+        if (previous !== undefined) {
+          setDialogs((prev) =>
+            prev.map((d) => (d.id === id ? { ...d, title: previous! } : d)),
+          )
+        }
+      }
+    },
+    [renameDialogCallback],
+  )
+
+  const archiveDialog = useCallback(
+    async (id: string): Promise<void> => {
+      if (!archiveDialogCallback) return
+      try {
+        await archiveDialogCallback(id)
+        setDialogs((prev) => prev.filter((d) => d.id !== id))
+        if (isManagedMode && internalDialogId === id) {
+          setInternalDialogId(null)
+        }
+      } catch (err) {
+        console.error('[useNatsChatAdapter] archiveDialog failed:', err)
+      }
+    },
+    [archiveDialogCallback, internalDialogId, isManagedMode],
+  )
+
   const loadMoreDialogs = useCallback(async (): Promise<void> => {
     if (!dialogsNextCursor) return
     await loadDialogsPage(dialogsNextCursor)
@@ -906,6 +987,8 @@ export function useNatsChatAdapter(
       selectDialog,
       startNewDialog,
       deleteDialog,
+      renameDialog,
+      archiveDialog,
       isDialogsLoading: isDialogsLoading || isCreatingDialog,
       isMessagesLoading,
       hasMoreDialogs,
@@ -934,6 +1017,8 @@ export function useNatsChatAdapter(
       selectDialog,
       startNewDialog,
       deleteDialog,
+      renameDialog,
+      archiveDialog,
       isDialogsLoading,
       isCreatingDialog,
       isMessagesLoading,

package/src/components/chat/hooks/use-sse-chat-adapter.ts

@@ -1071,6 +1071,8 @@ export function useSseChatAdapter(
     selectDialog: noopSelectDialog,
     startNewDialog: noopStartNewDialog,
     deleteDialog: noopDeleteDialog,
+    renameDialog: noopRenameDialog,
+    archiveDialog: noopArchiveDialog,
     isDialogsLoading: false,
     isMessagesLoading: false,
     hasMoreDialogs: false,
@@ -1096,6 +1098,12 @@ const noopStartNewDialog = async (): Promise<string | null> => null
 const noopDeleteDialog = async (_id: string): Promise<void> => {
   /* no-op until Guide localStorage history is exposed */
 }
+const noopRenameDialog = async (_id: string, _title: string): Promise<void> => {
+  /* no-op until Guide localStorage history is exposed */
+}
+const noopArchiveDialog = async (_id: string): Promise<void> => {
+  /* no-op until Guide localStorage history is exposed */
+}
 const noopAsync = async (): Promise<void> => {
   /* no-op pagination stub */
 }

package/src/components/chat/hooks/use-unified-chat.ts

@@ -157,6 +157,14 @@ export function useUnifiedChat(
     (id: string) => activeState.deleteDialog(id),
     [activeState],
   )
+  const renameDialog = useCallback(
+    (id: string, title: string) => activeState.renameDialog(id, title),
+    [activeState],
+  )
+  const archiveDialog = useCallback(
+    (id: string) => activeState.archiveDialog(id),
+    [activeState],
+  )
   const loadMoreDialogs = useCallback(
     () => activeState.loadMoreDialogs(),
     [activeState],
@@ -198,6 +206,8 @@ export function useUnifiedChat(
       selectDialog,
       startNewDialog,
       deleteDialog,
+      renameDialog,
+      archiveDialog,
       isDialogsLoading: activeState.isDialogsLoading,
       isMessagesLoading: activeState.isMessagesLoading,
       hasMoreDialogs: activeState.hasMoreDialogs,
@@ -221,6 +231,8 @@ export function useUnifiedChat(
       selectDialog,
       startNewDialog,
       deleteDialog,
+      renameDialog,
+      archiveDialog,
       loadMoreDialogs,
       loadMoreMessages,
       approveRequest,