@ifc-lite/viewer 1.17.4 → 1.17.6

package/src/lib/llm/stream-direct.ts

@@ -0,0 +1,316 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Direct browser-to-provider streaming for BYOK (Bring Your Own Key) models.
+ *
+ * Anthropic: Uses the official @anthropic-ai/sdk with `dangerouslyAllowBrowser`.
+ * OpenAI:    Uses fetch against the OpenAI chat completions API (same SSE format
+ *            the proxy already returns, so SSE parsing is shared).
+ *
+ * Keys are stored in localStorage and sent directly to the provider.
+ * They never pass through our server.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { readSseStream, type StreamMessage, type StreamOptions } from './stream-client.js';
+
+const STREAM_REQUEST_TIMEOUT_MS = 45_000;
+
+// ── Anthropic ──────────────────────────────────────────────────────────────
+
+type AnthropicMediaType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+
+type AnthropicContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: { type: 'base64'; media_type: AnthropicMediaType; data: string } };
+
+function toAnthropicMessages(
+  messages: StreamMessage[],
+): Array<{ role: 'user' | 'assistant'; content: string | AnthropicContentBlock[] }> {
+  return messages
+    .filter((m) => m.role === 'user' || m.role === 'assistant')
+    .map((m) => {
+      if (typeof m.content === 'string') {
+        return { role: m.role as 'user' | 'assistant', content: m.content };
+      }
+      // Multimodal content — convert OpenAI-style parts to Anthropic format
+      const blocks: AnthropicContentBlock[] = m.content.map((part) => {
+        if (part.type === 'text') {
+          return { type: 'text' as const, text: part.text };
+        }
+        // image_url → Anthropic image block
+        const dataUrl = part.image_url.url;
+        const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: 'image' as const,
+            source: {
+              type: 'base64' as const,
+              media_type: match[1] as AnthropicMediaType,
+              data: match[2],
+            },
+          };
+        }
+        // Fallback: pass URL as text
+        return { type: 'text' as const, text: `[Image: ${dataUrl.slice(0, 100)}]` };
+      });
+      return { role: m.role as 'user' | 'assistant', content: blocks };
+    });
+}
+
+export async function streamAnthropicChat(
+  apiKey: string,
+  options: Omit<StreamOptions, 'proxyUrl' | 'authToken' | 'onUsageInfo'>,
+): Promise<void> {
+  const { model, messages, system, signal, onChunk, onComplete, onError, onFinishReason } = options;
+
+  const client = new Anthropic({
+    apiKey,
+    dangerouslyAllowBrowser: true,
+  });
+
+  let fullText = '';
+  try {
+    const stream = client.messages.stream({
+      model,
+      max_tokens: 8192,
+      temperature: 0.3,
+      system: system || undefined,
+      messages: toAnthropicMessages(messages),
+    });
+
+    // Wire up abort signal
+    if (signal) {
+      const onAbort = () => stream.abort();
+      signal.addEventListener('abort', onAbort, { once: true });
+      stream.on('end', () => signal.removeEventListener('abort', onAbort));
+    }
+
+    stream.on('text', (text) => {
+      fullText += text;
+      onChunk(text);
+    });
+
+    const finalMessage = await stream.finalMessage();
+
+    if (signal?.aborted) return;
+
+    const stopReason = finalMessage.stop_reason;
+    onFinishReason?.(stopReason === 'end_turn' ? 'stop' : stopReason);
+    onComplete(fullText);
+  } catch (err) {
+    if (signal?.aborted) return;
+
+    if (err instanceof Anthropic.APIError) {
+      const msg = err.status === 401
+        ? 'Invalid Anthropic API key. Check your key in Settings.'
+        : err.status === 429
+          ? 'Anthropic rate limit reached. Please wait and try again.'
+          : `Anthropic error (${err.status}): ${err.message}`;
+      onError(new Error(msg));
+    } else {
+      onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+}
+
+// ── OpenAI ─────────────────────────────────────────────────────────────────
+
+import { getModelById } from './models.js';
+
+/**
+ * Stream an OpenAI model. Automatically picks the right API:
+ * - Chat Completions (`/v1/chat/completions`) for standard chat models
+ * - Responses (`/v1/responses`) for Codex-style models
+ */
+export async function streamOpenAiChat(
+  apiKey: string,
+  options: Omit<StreamOptions, 'proxyUrl' | 'authToken' | 'onUsageInfo'>,
+): Promise<void> {
+  const modelDef = getModelById(options.model);
+  if (modelDef?.openaiApi === 'responses') {
+    return streamOpenAiResponses(apiKey, options);
+  }
+  return streamOpenAiChatCompletions(apiKey, options);
+}
+
+/** Standard Chat Completions API (GPT-5.4, GPT-5.4 Mini, etc.) */
+async function streamOpenAiChatCompletions(
+  apiKey: string,
+  options: Omit<StreamOptions, 'proxyUrl' | 'authToken' | 'onUsageInfo'>,
+): Promise<void> {
+  const { model, messages, system, signal, onChunk, onComplete, onError, onFinishReason } = options;
+
+  const allMessages: StreamMessage[] = system
+    ? [{ role: 'system', content: system }, ...messages]
+    : [...messages];
+
+  const { response, cleanup } = await openAiFetch(
+    'https://api.openai.com/v1/chat/completions',
+    {
+      model,
+      messages: allMessages.map((m) => ({ role: m.role, content: m.content })),
+      stream: true,
+      temperature: 0.3,
+      max_completion_tokens: 8192,
+    },
+    apiKey,
+    signal,
+    onError,
+  );
+  if (!response) return;
+
+  if (!response.body) { cleanup(); onError(new Error('No response body')); return; }
+
+  let fullText = '';
+  let finishReason: string | null = null;
+
+  const ok = await readSseStream(response.body, signal, (data) => {
+    const parsed = JSON.parse(data) as {
+      choices?: Array<{ delta?: { content?: string }; finish_reason?: string | null }>;
+    };
+    const content = parsed.choices?.[0]?.delta?.content;
+    if (content) { fullText += content; onChunk(content); }
+    const fr = parsed.choices?.[0]?.finish_reason;
+    if (fr) finishReason = fr;
+  }, onError);
+
+  cleanup();
+  if (ok) { onFinishReason?.(finishReason); onComplete(fullText); }
+}
+
+/** Responses API for Codex-style models (GPT-5.3 Codex) */
+async function streamOpenAiResponses(
+  apiKey: string,
+  options: Omit<StreamOptions, 'proxyUrl' | 'authToken' | 'onUsageInfo'>,
+): Promise<void> {
+  const { model, messages, system, signal, onChunk, onComplete, onError, onFinishReason } = options;
+
+  // Build the input array: system instructions + conversation
+  const input: Array<{ role: string; content: string | unknown[] }> = [];
+  if (system) {
+    input.push({ role: 'developer', content: system });
+  }
+  for (const m of messages) {
+    input.push({ role: m.role, content: m.content });
+  }
+
+  const { response, cleanup } = await openAiFetch(
+    'https://api.openai.com/v1/responses',
+    {
+      model,
+      input,
+      stream: true,
+      max_output_tokens: 8192,
+    },
+    apiKey,
+    signal,
+    onError,
+  );
+  if (!response) return;
+
+  if (!response.body) { cleanup(); onError(new Error('No response body')); return; }
+
+  let fullText = '';
+  // Map Responses API terminal events → chat-style finish_reason.
+  // `response.incomplete` is any non-completed terminal state: when the
+  // reason is `max_output_tokens` — or simply absent — map to 'length' so
+  // the ChatPanel "Continue" UX can resume a truncated Codex reply. Other
+  // explicit reasons (e.g. `content_filter`) pass through unchanged.
+  let finishReason: string | null = 'stop';
+
+  const ok = await readSseStream(response.body, signal, (data) => {
+    const event = JSON.parse(data) as {
+      type?: string;
+      delta?: string;
+      response?: {
+        status?: string;
+        incomplete_details?: { reason?: string } | null;
+      };
+    };
+    if (event.type === 'response.output_text.delta' && event.delta) {
+      fullText += event.delta;
+      onChunk(event.delta);
+    } else if (event.type === 'response.incomplete') {
+      const reason = event.response?.incomplete_details?.reason;
+      finishReason = reason == null || reason === 'max_output_tokens' ? 'length' : reason;
+    } else if (event.type === 'response.completed') {
+      finishReason = 'stop';
+    }
+  }, onError);
+
+  cleanup();
+  if (ok) { onFinishReason?.(finishReason); onComplete(fullText); }
+}
+
+// ── Shared helpers ─────────────────────────────────────────────────────────
+
+async function openAiFetch(
+  url: string,
+  body: Record<string, unknown>,
+  apiKey: string,
+  signal: AbortSignal | undefined,
+  onError: (err: Error) => void,
+): Promise<{ response: Response | null; cleanup: () => void }> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(new Error('Chat request timed out. Please try again.')),
+    STREAM_REQUEST_TIMEOUT_MS,
+  );
+  const abortFromParent = () => controller.abort(signal?.reason);
+  if (signal) {
+    if (signal.aborted) { clearTimeout(timeoutId); return { response: null, cleanup: () => {} }; }
+    signal.addEventListener('abort', abortFromParent, { once: true });
+  }
+
+  // cleanup() clears the connect timeout and removes the abort listener.
+  // Callers must call it AFTER streaming completes, not before — otherwise
+  // user cancellation during SSE consumption won't abort the fetch.
+  const cleanup = () => {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener('abort', abortFromParent);
+  };
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+  } catch (err) {
+    cleanup();
+    if (signal?.aborted) return { response: null, cleanup: () => {} };
+    if (controller.signal.aborted && controller.signal.reason instanceof Error) {
+      onError(controller.signal.reason);
+    } else {
+      onError(err instanceof Error ? err : new Error(String(err)));
+    }
+    return { response: null, cleanup: () => {} };
+  }
+
+  if (!response.ok) {
+    cleanup();
+    let detail = `OpenAI error (${response.status})`;
+    try {
+      const errBody = (await response.json()) as { error?: { message?: string } };
+      if (response.status === 401) {
+        detail = 'Invalid OpenAI API key. Check your key in the chat panel.';
+      } else if (response.status === 429) {
+        detail = 'OpenAI rate limit reached. Please wait and try again.';
+      } else if (errBody.error?.message) {
+        detail = `OpenAI: ${errBody.error.message}`;
+      }
+    } catch { /* ignore parse failure */ }
+    onError(new Error(detail));
+    return { response: null, cleanup: () => {} };
+  }
+
+  return { response, cleanup };
+}

package/src/lib/llm/types.ts

@@ -126,7 +126,15 @@ export interface FileAttachment {
   isImage?: boolean;
 }
 
-export type ModelTier = 'free' | 'pro';
+export type ModelTier = 'free' | 'byok';
+
+/**
+ * Where requests for this model are routed.
+ * - 'proxy': through the server-side proxy (free models)
+ * - 'anthropic': direct browser-to-Anthropic API (user's own key)
+ * - 'openai': direct browser-to-OpenAI API (user's own key)
+ */
+export type ModelSource = 'proxy' | 'anthropic' | 'openai';
 
 /** Relative cost indicator for paid models */
 export type ModelCost = '$' | '$$' | '$$$';
@@ -136,6 +144,8 @@ export interface LLMModel {
   name: string;
   provider: string;
   tier: ModelTier;
+  /** Where requests are routed — proxy (free) or direct to provider (BYOK) */
+  source: ModelSource;
   contextWindow: number;
   /** Whether this model accepts image inputs in chat content */
   supportsImages: boolean;
@@ -143,8 +153,10 @@ export interface LLMModel {
   supportsFileAttachments: boolean;
   /** Notes shown in model selector */
   notes?: string;
-  /** Relative cost indicator (pro models only) */
+  /** Relative cost indicator (BYOK models only) */
   cost?: ModelCost;
+  /** OpenAI API variant: 'chat' (default) or 'responses' (Codex-style models) */
+  openaiApi?: 'chat' | 'responses';
 }
 
 export type ChatStatus = 'idle' | 'sending' | 'streaming' | 'error';

package/src/main.tsx

@@ -8,21 +8,12 @@
 
 import React from 'react';
 import ReactDOM from 'react-dom/client';
-import { ClerkProvider } from '@clerk/clerk-react';
 import { App } from './App';
 import './index.css';
 import 'maplibre-gl/dist/maplibre-gl.css';
 
-const clerkPublishableKey = (import.meta.env.VITE_CLERK_PUBLISHABLE_KEY as string | undefined)?.trim();
-
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
-    {clerkPublishableKey ? (
-      <ClerkProvider publishableKey={clerkPublishableKey}>
-        <App />
-      </ClerkProvider>
-    ) : (
-      <App />
-    )}
+    <App />
   </React.StrictMode>
 );

package/src/services/api-keys.ts

@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * BYOK (Bring Your Own Key) API key storage.
+ *
+ * Stores user-provided API keys for Anthropic and OpenAI in localStorage.
+ * Keys are sent directly from the browser to the provider APIs — they never
+ * pass through our server proxy.
+ */
+
+export interface ApiKeyConfig {
+  anthropicKey: string;
+  openaiKey: string;
+}
+
+const STORAGE_KEY = 'ifc-lite:api-keys:v1';
+const CHANGED_EVENT = 'ifc-lite:api-keys-changed';
+
+const EMPTY_CONFIG: ApiKeyConfig = {
+  anthropicKey: '',
+  openaiKey: '',
+};
+
+function sanitize(value: unknown): ApiKeyConfig {
+  const parsed = value && typeof value === 'object' ? (value as Partial<ApiKeyConfig>) : {};
+  return {
+    anthropicKey: typeof parsed.anthropicKey === 'string' ? parsed.anthropicKey.trim() : '',
+    openaiKey: typeof parsed.openaiKey === 'string' ? parsed.openaiKey.trim() : '',
+  };
+}
+
+export function getApiKeys(): ApiKeyConfig {
+  try {
+    return sanitize(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}'));
+  } catch {
+    return { ...EMPTY_CONFIG };
+  }
+}
+
+export function updateApiKeys(updates: Partial<ApiKeyConfig>): ApiKeyConfig {
+  const next = { ...getApiKeys(), ...updates };
+  // Trim keys before saving
+  next.anthropicKey = next.anthropicKey.trim();
+  next.openaiKey = next.openaiKey.trim();
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+  return next;
+}
+
+export function clearApiKeys(): ApiKeyConfig {
+  localStorage.removeItem(STORAGE_KEY);
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+  return { ...EMPTY_CONFIG };
+}
+
+export function subscribeApiKeys(listener: () => void): () => void {
+  window.addEventListener(CHANGED_EVENT, listener);
+  return () => window.removeEventListener(CHANGED_EVENT, listener);
+}
+
+export function hasAnthropicKey(): boolean {
+  return getApiKeys().anthropicKey.length > 0;
+}
+
+export function hasOpenaiKey(): boolean {
+  return getApiKeys().openaiKey.length > 0;
+}
+
+export function hasAnyApiKey(): boolean {
+  return hasAnthropicKey() || hasOpenaiKey();
+}

package/src/store/constants.ts

@@ -30,6 +30,24 @@ export const SECTION_PLANE_DEFAULTS = {
   ENABLED: true,
   /** Default flipped state */
   FLIPPED: false,
+  /** Default: render filled/hatched cap surfaces at the cut */
+  SHOW_CAP: true,
+  /** Default: draw polygon outlines on the cut surfaces */
+  SHOW_OUTLINES: true,
+} as const;
+
+/**
+ * Default cut-surface appearance. RGBA tuples are 0-1 per channel. Screen-space
+ * hatch settings are in pixels so the hatch stays readable at any zoom level.
+ */
+export const SECTION_CAP_DEFAULTS = {
+  FILL_COLOR:   [0.92, 0.88, 0.78, 1.0] as [number, number, number, number], // warm paper
+  STROKE_COLOR: [0.10, 0.10, 0.10, 1.0] as [number, number, number, number], // ink
+  PATTERN:      'diagonal' as const,
+  SPACING_PX:   8,
+  ANGLE_RAD:    Math.PI / 4,
+  WIDTH_PX:     1.0,
+  SECONDARY_ANGLE_RAD: -Math.PI / 4,
 } as const;
 
 // ============================================================================
@@ -52,10 +70,10 @@ export const EDGE_LOCK_DEFAULTS = {
 // ============================================================================
 
 /** Resolve the initial theme: localStorage override > system preference > dark fallback */
-function getInitialTheme(): 'light' | 'dark' {
+function getInitialTheme(): 'light' | 'dark' | 'colorful' {
   if (typeof window === 'undefined') return 'dark';
   const saved = localStorage.getItem('ifc-lite-theme');
-  if (saved === 'light' || saved === 'dark') return saved;
+  if (saved === 'light' || saved === 'dark' || saved === 'colorful') return saved;
   return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
 }
 

package/src/store/index.ts

@@ -43,7 +43,7 @@ import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_D
 export type * from './types.js';
 
 // Explicitly re-export multi-model types that need to be imported by name
-export type { EntityRef, SchemaVersion, FederatedModel, MeasurementConstraintEdge, OrthogonalAxis } from './types.js';
+export type { EntityRef, SchemaVersion, FederatedModel, MeasurementConstraintEdge, OrthogonalAxis, SectionCapStyle, SectionCapHatchId, SectionPlane, SectionPlaneAxis } from './types.js';
 
 // Re-export utility functions for entity references
 export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore } from './types.js';
@@ -195,12 +195,18 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
         cornerValence: 0,
       },
 
-      // Section plane
+      // Section plane: reset axis/position/enabled/flipped (those are
+      // model-relative and meaningless when switching files), but PRESERVE
+      // the user's cap appearance preferences (showCap, showOutlines,
+      // capStyle). Those round-trip to localStorage via the slice's
+      // persistence helpers; clobbering them here was the cause of "my
+      // hatch / colour resets to defaults every time I open a file".
       sectionPlane: {
-        axis: SECTION_PLANE_DEFAULTS.AXIS,
+        ...get().sectionPlane,
+        axis:     SECTION_PLANE_DEFAULTS.AXIS,
         position: SECTION_PLANE_DEFAULTS.POSITION,
-        enabled: SECTION_PLANE_DEFAULTS.ENABLED,
-        flipped: SECTION_PLANE_DEFAULTS.FLIPPED,
+        enabled:  SECTION_PLANE_DEFAULTS.ENABLED,
+        flipped:  SECTION_PLANE_DEFAULTS.FLIPPED,
       },
 
       // Camera
@@ -224,6 +230,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
 
       // Cesium
+      cesiumAvailable: false,
       cesiumEnabled: false,
       cesiumTerrainHeight: null,
       cesiumTerrainClamp: false,

package/src/store/slices/cesiumSlice.ts

@@ -23,6 +23,8 @@ export type CesiumDataSource =
 
 export interface CesiumSlice {
   // State
+  /** Whether a loaded model (or user mutations) provide enough georeferencing to place in Cesium. */
+  cesiumAvailable: boolean;
   cesiumEnabled: boolean;
   cesiumDataSource: CesiumDataSource;
   /** Resolved Cesium ion access token (user override or build-time default). */
@@ -41,6 +43,7 @@ export interface CesiumSlice {
   cesiumGlbLoaded: boolean;
 
   // Actions
+  setCesiumAvailable: (available: boolean) => void;
   setCesiumEnabled: (enabled: boolean) => void;
   toggleCesium: () => void;
   setCesiumDataSource: (source: CesiumDataSource) => void;
@@ -93,6 +96,7 @@ function resolveIonToken(): string {
 }
 
 export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> = (set) => ({
+  cesiumAvailable: false,
   cesiumEnabled: false,
   cesiumDataSource: loadDataSource(),
   cesiumIonToken: resolveIonToken(),
@@ -103,6 +107,7 @@ export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> =
   cesiumTerrainClipY: null,
   cesiumGlbLoaded: false,
 
+  setCesiumAvailable: (available) => set({ cesiumAvailable: available }),
   setCesiumEnabled: (enabled) => set({ cesiumEnabled: enabled }),
   toggleCesium: () => set((s) => ({ cesiumEnabled: !s.cesiumEnabled })),
   setCesiumDataSource: (source) => {

package/src/store/slices/chatSlice.test.ts

@@ -8,7 +8,7 @@ import { buildErrorFeedbackContent } from './chatSlice.js';
 import { create } from 'zustand';
 import { createChatSlice, type ChatSlice } from './chatSlice.js';
 import { createPatchDiagnostic, createPreflightDiagnostic } from '../../lib/llm/script-diagnostics.js';
-import { DEFAULT_FREE_MODEL, DEFAULT_PRO_MODEL } from '../../lib/llm/models.js';
+import { DEFAULT_FREE_MODEL, DEFAULT_BYOK_MODEL } from '../../lib/llm/models.js';
 
 function withMockLocalStorage(fn: () => void) {
   const original = globalThis.localStorage;
@@ -217,52 +217,14 @@ test('clearChatMessages resets streaming state as well as persisted messages', (
   assert.deepEqual(useChatStore.getState().chatAttachments, []);
 });
 
-test('switchChatUserContext restores per-user history and coerces disallowed models', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-a', DEFAULT_PRO_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'persisted-a',
-        role: 'user',
-        content: 'hello from A',
-        createdAt: 1,
-      },
-    ]));
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-b', DEFAULT_FREE_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-b', JSON.stringify([
-      {
-        id: 'persisted-b',
-        role: 'assistant',
-        content: 'hello from B',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', true, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_PRO_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-a');
-
-    useChatStore.getState().switchChatUserContext('user-b', false, {
-      clearPersistedCurrent: true,
-      restoreMessages: true,
-    });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-b');
-    assert.equal(globalThis.localStorage.getItem('ifc-lite-chat-messages:user-a'), null);
-  });
-});
-
-test('setChatHasPro falls back to a free model when entitlement is removed', () => {
+test('setChatHasByokKey falls back to a free model when keys are removed', () => {
   const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-  useChatStore.getState().setChatHasPro(true);
-  useChatStore.getState().setChatActiveModel(DEFAULT_PRO_MODEL.id);
+  useChatStore.getState().setChatHasByokKey(true);
+  useChatStore.getState().setChatActiveModel(DEFAULT_BYOK_MODEL.id);
 
-  useChatStore.getState().setChatHasPro(false);
+  useChatStore.getState().setChatHasByokKey(false);
 
-  assert.equal(useChatStore.getState().chatHasPro, false);
+  assert.equal(useChatStore.getState().chatHasByokKey, false);
   assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
 });
 
@@ -291,35 +253,3 @@ test('removeChatAttachment only removes the targeted attachment id', () => {
   );
 });
 
-test('switchChatUserContext ignores malformed persisted messages', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'valid',
-        role: 'user',
-        content: 'hello',
-        createdAt: 1,
-        attachments: [
-          { id: 'att-1', name: 'ok.csv', type: 'text/csv', size: 20, textContent: 'a,b\n1,2' },
-          { name: 'missing-id.csv', type: 'text/csv', size: 20 },
-        ],
-      },
-      {
-        id: 123,
-        role: 'assistant',
-        content: 'bad',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', false, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatMessages.length, 1);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'valid');
-    assert.deepEqual(
-      useChatStore.getState().chatMessages[0]?.attachments?.map((attachment) => attachment.id),
-      ['att-1'],
-    );
-  });
-});