@nextclaw/ui 0.7.0 → 0.9.0

package/src/components/chat/ncp/ncp-chat-page-data.ts

@@ -0,0 +1,166 @@
+import { useMemo } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import type { SessionEntryView } from '@/api/types';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import {
+  adaptNcpSessionSummaries,
+  readNcpSessionPreferredThinking
+} from '@/components/chat/ncp/ncp-session-adapter';
+import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
+import {
+  resolveSelectedModelValue,
+  resolveRecentSessionPreferredModel,
+  useSyncSelectedModel
+} from '@/components/chat/chat-page-runtime';
+import {
+  useConfig,
+  useConfigMeta,
+  useNcpSessions
+} from '@/hooks/useConfig';
+import { useNcpChatSessionTypes } from '@/hooks/use-ncp-chat-session-types';
+import { useMarketplaceInstalled } from '@/hooks/useMarketplace';
+import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/lib/provider-models';
+
+type UseNcpChatPageDataParams = {
+  query: string;
+  selectedSessionKey: string | null;
+  pendingSessionType: string;
+  setPendingSessionType: Dispatch<SetStateAction<string>>;
+  setSelectedModel: Dispatch<SetStateAction<string>>;
+};
+
+function filterSessionsByQuery(sessions: SessionEntryView[], query: string): SessionEntryView[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) {
+    return sessions;
+  }
+  return sessions.filter((session) => session.key.toLowerCase().includes(normalizedQuery));
+}
+
+export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
+  const configQuery = useConfig();
+  const configMetaQuery = useConfigMeta();
+  const sessionsQuery = useNcpSessions({ limit: 200 });
+  const sessionTypesQuery = useNcpChatSessionTypes();
+  const installedSkillsQuery = useMarketplaceInstalled('skill');
+  const isProviderStateResolved =
+    (configQuery.isFetched || configQuery.isSuccess) &&
+    (configMetaQuery.isFetched || configMetaQuery.isSuccess);
+
+  const modelOptions = useMemo<ChatModelOption[]>(() => {
+    const providers = buildProviderModelCatalog({
+      meta: configMetaQuery.data,
+      config: configQuery.data,
+      onlyConfigured: true
+    });
+    const seen = new Set<string>();
+    const options: ChatModelOption[] = [];
+    for (const provider of providers) {
+      for (const localModel of provider.models) {
+        const value = composeProviderModel(provider.prefix, localModel);
+        if (!value || seen.has(value)) {
+          continue;
+        }
+        seen.add(value);
+        options.push({
+          value,
+          modelLabel: localModel,
+          providerLabel: provider.displayName,
+          thinkingCapability: resolveModelThinkingCapability(provider.modelThinking, localModel, provider.aliases)
+        });
+      }
+    }
+    return options.sort((left, right) => {
+      const providerCompare = left.providerLabel.localeCompare(right.providerLabel);
+      if (providerCompare !== 0) {
+        return providerCompare;
+      }
+      return left.modelLabel.localeCompare(right.modelLabel);
+    });
+  }, [configMetaQuery.data, configQuery.data]);
+
+  const sessionSummaries = useMemo(
+    () => sessionsQuery.data?.sessions ?? [],
+    [sessionsQuery.data?.sessions]
+  );
+  const allSessions = useMemo(
+    () => adaptNcpSessionSummaries(sessionSummaries),
+    [sessionSummaries]
+  );
+  const sessions = useMemo(
+    () => filterSessionsByQuery(allSessions, params.query),
+    [allSessions, params.query]
+  );
+  const selectedSession = useMemo(
+    () => allSessions.find((session) => session.key === params.selectedSessionKey) ?? null,
+    [allSessions, params.selectedSessionKey]
+  );
+  const selectedSessionSummary = useMemo(
+    () => sessionSummaries.find((session) => session.sessionId === params.selectedSessionKey) ?? null,
+    [params.selectedSessionKey, sessionSummaries]
+  );
+  const skillRecords = useMemo(
+    () => installedSkillsQuery.data?.records ?? [],
+    [installedSkillsQuery.data?.records]
+  );
+  const selectedSessionThinkingLevel = useMemo(
+    () => (selectedSessionSummary ? readNcpSessionPreferredThinking(selectedSessionSummary) : null),
+    [selectedSessionSummary]
+  );
+
+  const sessionTypeState = useChatSessionTypeState({
+    selectedSession,
+    selectedSessionKey: params.selectedSessionKey,
+    pendingSessionType: params.pendingSessionType,
+    setPendingSessionType: params.setPendingSessionType,
+    sessionTypesData: sessionTypesQuery.data
+  });
+  const recentSessionPreferredModel = useMemo(
+    () =>
+      resolveRecentSessionPreferredModel({
+        sessions: allSessions,
+        selectedSessionKey: params.selectedSessionKey,
+        sessionType: sessionTypeState.selectedSessionType
+      }),
+    [allSessions, params.selectedSessionKey, sessionTypeState.selectedSessionType]
+  );
+
+  useSyncSelectedModel({
+    modelOptions,
+    selectedSessionKey: params.selectedSessionKey,
+    selectedSessionPreferredModel: selectedSession?.preferredModel,
+    fallbackPreferredModel: recentSessionPreferredModel,
+    defaultModel: configQuery.data?.agents.defaults.model,
+    setSelectedModel: params.setSelectedModel
+  });
+
+  const hydratedSessionModel = useMemo(
+    () =>
+      resolveSelectedModelValue({
+        currentSelectedModel: '',
+        modelOptions,
+        selectedSessionPreferredModel: selectedSession?.preferredModel,
+        fallbackPreferredModel: recentSessionPreferredModel,
+        defaultModel: configQuery.data?.agents.defaults.model,
+        preferSessionPreferredModel: true
+      }),
+    [configQuery.data?.agents.defaults.model, modelOptions, recentSessionPreferredModel, selectedSession?.preferredModel]
+  );
+
+  return {
+    configQuery,
+    configMetaQuery,
+    sessionsQuery,
+    sessionTypesQuery,
+    installedSkillsQuery,
+    isProviderStateResolved,
+    modelOptions,
+    sessionSummaries,
+    sessions,
+    skillRecords,
+    selectedSession,
+    hydratedSessionModel,
+    selectedSessionThinkingLevel,
+    ...sessionTypeState
+  };
+}

package/src/components/chat/ncp/ncp-chat-thread.manager.ts

@@ -0,0 +1,89 @@
+import { deleteNcpSession as deleteNcpSessionApi } from '@/api/ncp-session';
+import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import type { ChatThreadSnapshot } from '@/components/chat/stores/chat-thread.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
+import { t } from '@/lib/i18n';
+
+export type NcpChatThreadManagerActions = {
+  refetchSessions: () => Promise<unknown>;
+};
+
+const noopAsync = async () => {};
+
+export class NcpChatThreadManager {
+  private actions: NcpChatThreadManagerActions = {
+    refetchSessions: noopAsync
+  };
+
+  constructor(
+    private uiManager: ChatUiManager,
+    private sessionListManager: ChatSessionListManager,
+    private streamActionsManager: ChatStreamActionsManager
+  ) {}
+
+  bindActions = (patch: Partial<NcpChatThreadManagerActions>) => {
+    this.actions = {
+      ...this.actions,
+      ...patch
+    };
+  };
+
+  private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
+    const current = useChatThreadStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatThreadSnapshot, ChatThreadSnapshot[keyof ChatThreadSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  syncSnapshot = (patch: Partial<ChatThreadSnapshot>) => {
+    if (!this.hasSnapshotChanges(patch)) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot(patch);
+  };
+
+  deleteSession = () => {
+    void this.deleteCurrentSession();
+  };
+
+  createSession = () => {
+    this.sessionListManager.createSession();
+  };
+
+  goToProviders = () => {
+    this.uiManager.goToProviders();
+  };
+
+  private deleteCurrentSession = async () => {
+    const {
+      snapshot: { selectedSessionKey }
+    } = useChatSessionListStore.getState();
+    if (!selectedSessionKey) {
+      return;
+    }
+    const confirmed = await this.uiManager.confirm({
+      title: t('chatDeleteSessionConfirm'),
+      variant: 'destructive',
+      confirmLabel: t('delete')
+    });
+    if (!confirmed) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({ isDeletePending: true });
+    try {
+      await deleteNcpSessionApi(selectedSessionKey);
+      this.streamActionsManager.resetStreamState();
+      useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: null });
+      this.uiManager.goToChatRoot({ replace: true });
+      await this.actions.refetchSessions();
+    } finally {
+      useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
+    }
+  };
+}

package/src/components/chat/ncp/ncp-chat.presenter.ts

@@ -0,0 +1,33 @@
+import { ChatRunStatusManager } from '@/components/chat/managers/chat-run-status.manager';
+import { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { NcpChatInputManager } from '@/components/chat/ncp/ncp-chat-input.manager';
+import { NcpChatThreadManager } from '@/components/chat/ncp/ncp-chat-thread.manager';
+
+export class NcpChatPresenter {
+  chatUiManager = new ChatUiManager();
+  chatStreamActionsManager = new ChatStreamActionsManager();
+  chatSessionListManager = new ChatSessionListManager(this.chatUiManager, this.chatStreamActionsManager);
+  chatInputManager = new NcpChatInputManager(
+    this.chatUiManager,
+    this.chatStreamActionsManager,
+    () => this.getDraftSessionId()
+  );
+  chatRunStatusManager = new ChatRunStatusManager();
+  chatThreadManager = new NcpChatThreadManager(
+    this.chatUiManager,
+    this.chatSessionListManager,
+    this.chatStreamActionsManager
+  );
+
+  private draftSessionId = '';
+
+  setDraftSessionId = (sessionId: string) => {
+    this.draftSessionId = sessionId;
+  };
+
+  private getDraftSessionId(): string {
+    return this.draftSessionId;
+  }
+}

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -0,0 +1,75 @@
+import {
+  adaptNcpSessionSummary,
+  buildNcpSessionRunStatusByKey,
+  readNcpSessionPreferredThinking
+} from '@/components/chat/ncp/ncp-session-adapter';
+import type { NcpSessionSummaryView } from '@/api/types';
+
+function createSummary(partial: Partial<NcpSessionSummaryView> = {}): NcpSessionSummaryView {
+  return {
+    sessionId: 'ncp-session-1',
+    messageCount: 3,
+    updatedAt: '2026-03-18T00:00:00.000Z',
+    status: 'idle',
+    ...partial
+  };
+}
+
+describe('adaptNcpSessionSummary', () => {
+  it('maps session metadata into shared session entry fields', () => {
+    const adapted = adaptNcpSessionSummary(
+      createSummary({
+        metadata: {
+          label: 'NCP Planning Thread',
+          model: 'openai/gpt-5',
+          session_type: 'native'
+        }
+      })
+    );
+
+    expect(adapted).toMatchObject({
+      key: 'ncp-session-1',
+      label: 'NCP Planning Thread',
+      preferredModel: 'openai/gpt-5',
+      sessionType: 'native',
+      sessionTypeMutable: false,
+      messageCount: 3
+    });
+  });
+});
+
+describe('readNcpSessionPreferredThinking', () => {
+  it('normalizes persisted thinking metadata for UI hydration', () => {
+    const thinking = readNcpSessionPreferredThinking(
+      createSummary({
+        metadata: {
+          preferred_thinking: 'HIGH'
+        }
+      })
+    );
+
+    expect(thinking).toBe('high');
+  });
+});
+
+describe('buildNcpSessionRunStatusByKey', () => {
+  it('marks the active local session as running before the server summary catches up', () => {
+    const statuses = buildNcpSessionRunStatusByKey({
+      summaries: [createSummary({ sessionId: 'ncp-session-1', status: 'idle' })],
+      activeSessionId: 'ncp-session-1',
+      isLocallyRunning: true
+    });
+
+    expect(statuses.get('ncp-session-1')).toBe('running');
+  });
+
+  it('keeps persisted running sessions marked as running', () => {
+    const statuses = buildNcpSessionRunStatusByKey({
+      summaries: [createSummary({ sessionId: 'ncp-session-2', status: 'running' })],
+      activeSessionId: null,
+      isLocallyRunning: false
+    });
+
+    expect(statuses.get('ncp-session-2')).toBe('running');
+  });
+});

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -0,0 +1,214 @@
+import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
+import type { NcpMessagePart } from '@nextclaw/ncp';
+import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/api/types';
+import type { SessionRunStatus } from '@/lib/session-run-status';
+
+const THINKING_LEVEL_SET = new Set<string>(['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh']);
+
+function stringifyUnknown(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return String(value ?? '');
+  }
+}
+
+function readOptionalString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function readMetadata(summary: NcpSessionSummaryView): Record<string, unknown> | null {
+  const { metadata } = summary;
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+    return null;
+  }
+  return metadata as Record<string, unknown>;
+}
+
+export function readNcpSessionPreferredModel(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return (
+    readOptionalString(metadata.preferred_model) ??
+    readOptionalString(metadata.preferredModel) ??
+    readOptionalString(metadata.model)
+  );
+}
+
+export function readNcpSessionPreferredThinking(summary: NcpSessionSummaryView): ThinkingLevel | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  const rawValue =
+    readOptionalString(metadata.preferred_thinking) ??
+    readOptionalString(metadata.thinking) ??
+    readOptionalString(metadata.thinking_level) ??
+    readOptionalString(metadata.thinkingLevel);
+  if (!rawValue) {
+    return null;
+  }
+  const normalized = rawValue.toLowerCase();
+  return THINKING_LEVEL_SET.has(normalized) ? (normalized as ThinkingLevel) : null;
+}
+
+function readNcpSessionLabel(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.label);
+}
+
+function readNcpSessionType(summary: NcpSessionSummaryView): string {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return 'native';
+  }
+  return readOptionalString(metadata.session_type) ?? readOptionalString(metadata.sessionType) ?? 'native';
+}
+
+function mapToolStatus(part: Extract<NcpMessagePart, { type: 'tool-invocation' }>): ToolInvocationStatus {
+  if (part.state === 'result') {
+    return ToolInvocationStatus.RESULT;
+  }
+  if (part.state === 'partial-call') {
+    return ToolInvocationStatus.PARTIAL_CALL;
+  }
+  return ToolInvocationStatus.CALL;
+}
+
+function toUiParts(parts: NcpMessagePart[]): UIMessage['parts'] {
+  const uiParts: UIMessage['parts'] = [];
+  for (const part of parts) {
+    if (part.type === 'text') {
+      uiParts.push({ type: 'text', text: part.text });
+      continue;
+    }
+    if (part.type === 'rich-text') {
+      uiParts.push({ type: 'text', text: part.text });
+      continue;
+    }
+    if (part.type === 'reasoning') {
+      uiParts.push({
+        type: 'reasoning',
+        reasoning: part.text,
+        details: []
+      });
+      continue;
+    }
+    if (part.type === 'source') {
+      uiParts.push({
+        type: 'source',
+        source: {
+          sourceType: 'url',
+          id: part.url ?? part.title ?? Math.random().toString(36).slice(2, 8),
+          url: part.url ?? '',
+          ...(part.title ? { title: part.title } : {})
+        }
+      });
+      continue;
+    }
+    if (part.type === 'file' && part.contentBase64) {
+      uiParts.push({
+        type: 'file',
+        mimeType: part.mimeType ?? 'application/octet-stream',
+        data: part.contentBase64
+      });
+      continue;
+    }
+    if (part.type === 'step-start') {
+      uiParts.push({ type: 'step-start' });
+      continue;
+    }
+    if (part.type === 'tool-invocation') {
+      uiParts.push({
+        type: 'tool-invocation',
+        toolInvocation: {
+          status: mapToolStatus(part),
+          toolCallId: part.toolCallId ?? `${part.toolName}-${Math.random().toString(36).slice(2, 8)}`,
+          toolName: part.toolName,
+          args: stringifyUnknown(part.args),
+          result: part.result
+        }
+      });
+    }
+  }
+  return uiParts;
+}
+
+function normalizeRole(role: NcpMessageView['role']): UIMessage['role'] {
+  if (role === 'service') {
+    return 'system';
+  }
+  return role === 'tool' ? 'assistant' : role;
+}
+
+export function adaptNcpMessageToUiMessage(message: NcpMessageView): UIMessage {
+  return {
+    id: message.id,
+    role: normalizeRole(message.role),
+    parts: toUiParts(message.parts),
+    meta: {
+      source: 'stream',
+      status: message.status,
+      sessionKey: message.sessionId,
+      timestamp: message.timestamp
+    }
+  };
+}
+
+export function adaptNcpMessagesToUiMessages(messages: readonly NcpMessageView[]): UIMessage[] {
+  console.log('[adaptNcpMessagesToUiMessages]', { messages });
+  return messages.map(adaptNcpMessageToUiMessage);
+}
+
+export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionEntryView {
+  const label = readNcpSessionLabel(summary);
+  const preferredModel = readNcpSessionPreferredModel(summary);
+  return {
+    key: summary.sessionId,
+    createdAt: summary.updatedAt,
+    updatedAt: summary.updatedAt,
+    ...(label ? { label } : {}),
+    ...(preferredModel ? { preferredModel } : {}),
+    sessionType: readNcpSessionType(summary),
+    sessionTypeMutable: false,
+    messageCount: summary.messageCount
+  };
+}
+
+export function adaptNcpSessionSummaries(summaries: NcpSessionSummaryView[]): SessionEntryView[] {
+  return summaries.map(adaptNcpSessionSummary);
+}
+
+export function buildNcpSessionRunStatusByKey(params: {
+  summaries: readonly NcpSessionSummaryView[];
+  activeSessionId?: string | null;
+  isLocallyRunning?: boolean;
+}): Map<string, SessionRunStatus> {
+  const map = new Map<string, SessionRunStatus>();
+  for (const summary of params.summaries) {
+    if (summary.status === 'running') {
+      map.set(summary.sessionId, 'running');
+    }
+  }
+  const activeSessionId = readOptionalString(params.activeSessionId);
+  if (params.isLocallyRunning && activeSessionId) {
+    map.set(activeSessionId, 'running');
+  }
+  return map;
+}
+
+export function createNcpSessionId(): string {
+  return `ncp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}

package/src/components/chat/presenter/chat-presenter-context.tsx

@@ -1,11 +1,50 @@
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
-import type { ChatPresenter } from '@/components/chat/presenter/chat.presenter';
+import type { SetStateAction } from 'react';
+import type { ChatRunStatusManager } from '@/components/chat/managers/chat-run-status.manager';
+import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import type { ChatThreadSnapshot } from '@/components/chat/stores/chat-thread.store';
+import type { ThinkingLevel } from '@/api/types';
 
-const ChatPresenterContext = createContext<ChatPresenter | null>(null);
+export type ChatInputManagerLike = {
+  syncSnapshot: (patch: Record<string, unknown>) => void;
+  setDraft: (next: SetStateAction<string>) => void;
+  setPendingSessionType: (next: SetStateAction<string>) => void;
+  send: () => Promise<void>;
+  stop: () => Promise<void>;
+  goToProviders: () => void;
+  setSelectedModel: (next: SetStateAction<string>) => void;
+  setSelectedThinkingLevel: (next: SetStateAction<ThinkingLevel | null>) => void;
+  setSelectedSkills: (next: SetStateAction<string[]>) => void;
+  selectSessionType: (value: string) => void;
+  selectModel: (value: string) => void;
+  selectThinkingLevel: (value: ThinkingLevel) => void;
+  selectSkills: (next: string[]) => void;
+};
+
+export type ChatThreadManagerLike = {
+  bindActions: (patch: { refetchSessions?: () => Promise<unknown> }) => void;
+  syncSnapshot: (patch: Partial<ChatThreadSnapshot>) => void;
+  deleteSession: () => void;
+  createSession: () => void;
+  goToProviders: () => void;
+};
+
+export type ChatPresenterLike = {
+  chatUiManager: ChatUiManager;
+  chatStreamActionsManager: ChatStreamActionsManager;
+  chatInputManager: ChatInputManagerLike;
+  chatSessionListManager: ChatSessionListManager;
+  chatRunStatusManager: ChatRunStatusManager;
+  chatThreadManager: ChatThreadManagerLike;
+};
+
+const ChatPresenterContext = createContext<ChatPresenterLike | null>(null);
 
 type ChatPresenterProviderProps = {
-  presenter: ChatPresenter;
+  presenter: ChatPresenterLike;
   children: ReactNode;
 };
 
@@ -13,7 +52,7 @@ export function ChatPresenterProvider({ presenter, children }: ChatPresenterProv
   return <ChatPresenterContext.Provider value={presenter}>{children}</ChatPresenterContext.Provider>;
 }
 
-export function usePresenter(): ChatPresenter {
+export function usePresenter(): ChatPresenterLike {
   const presenter = useContext(ChatPresenterContext);
   if (!presenter) {
     throw new Error('usePresenter must be used inside ChatPresenterProvider');

package/src/components/chat/stores/chat-thread.store.ts

@@ -8,6 +8,7 @@ export type ChatThreadSnapshot = {
   modelOptions: ChatModelOption[];
   sessionTypeUnavailable: boolean;
   sessionTypeUnavailableMessage?: string | null;
+  sessionTypeLabel?: string | null;
   selectedSessionKey: string | null;
   sessionDisplayName?: string;
   canDeleteSession: boolean;
@@ -29,6 +30,7 @@ const initialSnapshot: ChatThreadSnapshot = {
   modelOptions: [],
   sessionTypeUnavailable: false,
   sessionTypeUnavailableMessage: null,
+  sessionTypeLabel: null,
   selectedSessionKey: null,
   sessionDisplayName: undefined,
   canDeleteSession: false,