@ifc-lite/viewer 1.17.3 → 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/lib/recent-files.ts

@@ -103,7 +103,8 @@ export async function cacheFileBlobs(files: File[]): Promise<void> {
 }
 
 /** Retrieve a cached file blob and reconstruct a File object. */
-export async function getCachedFile(name: string): Promise<File | null> {
+export async function getCachedFile(target: string | RecentFileEntry): Promise<File | null> {
+  const name = typeof target === 'string' ? target : target.name;
   try {
     const db = await openDB();
     const tx = db.transaction(STORE_NAME, 'readonly');

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/analysis-extensions.ts

@@ -0,0 +1,125 @@
+/* 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/. */
+
+import type { ComponentType, ReactNode } from 'react';
+
+export type AnalysisExtensionPlacement = 'right' | 'bottom';
+
+export interface AnalysisExtensionRenderProps {
+  onClose: () => void;
+}
+
+export interface AnalysisExtensionDefinition {
+  id: string;
+  label: string;
+  description?: string;
+  placement?: AnalysisExtensionPlacement;
+  icon: ComponentType<{ className?: string }>;
+  renderPanel: (props: AnalysisExtensionRenderProps) => ReactNode;
+  onBeforeOpen?: () => boolean | void;
+}
+
+export interface AnalysisExtensionsSnapshot {
+  activeId: string | null;
+  extensions: AnalysisExtensionDefinition[];
+}
+
+const listeners = new Set<() => void>();
+const extensions = new Map<string, AnalysisExtensionDefinition>();
+
+let activeId: string | null = null;
+let snapshot: AnalysisExtensionsSnapshot = {
+  activeId,
+  extensions: [],
+};
+
+function rebuildSnapshot(): void {
+  snapshot = {
+    activeId,
+    extensions: Array.from(extensions.values()),
+  };
+}
+
+function emit(): void {
+  rebuildSnapshot();
+  listeners.forEach((listener) => listener());
+}
+
+function setActiveId(nextActiveId: string | null): void {
+  if (activeId === nextActiveId) {
+    return;
+  }
+  activeId = nextActiveId;
+  emit();
+}
+
+function canOpen(definition: AnalysisExtensionDefinition): boolean {
+  return definition.onBeforeOpen?.() !== false;
+}
+
+export function subscribeAnalysisExtensions(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function getAnalysisExtensionsSnapshot(): AnalysisExtensionsSnapshot {
+  return snapshot;
+}
+
+export function getAnalysisExtensionById(id: string | null | undefined): AnalysisExtensionDefinition | null {
+  if (!id) {
+    return null;
+  }
+  return extensions.get(id) ?? null;
+}
+
+export function closeActiveAnalysisExtension(): void {
+  setActiveId(null);
+}
+
+export function openAnalysisExtension(id: string): boolean {
+  const definition = extensions.get(id);
+  if (!definition) {
+    return false;
+  }
+  if (!canOpen(definition)) {
+    return false;
+  }
+  setActiveId(id);
+  return true;
+}
+
+export function toggleAnalysisExtension(id: string): boolean {
+  if (activeId === id) {
+    closeActiveAnalysisExtension();
+    return false;
+  }
+  return openAnalysisExtension(id);
+}
+
+export function registerAnalysisExtensions(definitions: AnalysisExtensionDefinition[]): () => void {
+  const nextEntries = definitions.map((definition) => [definition.id, definition] as const);
+  nextEntries.forEach(([id, definition]) => {
+    extensions.set(id, definition);
+  });
+  emit();
+
+  return () => {
+    let shouldEmit = false;
+    for (const [id] of nextEntries) {
+      if (extensions.delete(id)) {
+        shouldEmit = true;
+      }
+      if (activeId === id) {
+        activeId = null;
+        shouldEmit = true;
+      }
+    }
+    if (shouldEmit) {
+      emit();
+    }
+  };
+}

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/services/app-navigation.ts

@@ -0,0 +1,13 @@
+/* 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/. */
+
+export function navigateToPath(path: string, options: { replace?: boolean } = {}): void {
+  const { replace = false } = options;
+  if (replace) {
+    window.history.replaceState({}, '', path);
+  } else {
+    window.history.pushState({}, '', path);
+  }
+  window.dispatchEvent(new PopStateEvent('popstate'));
+}

package/src/services/bsdd.ts

@@ -99,6 +99,40 @@ async function fetchJson<T>(url: string): Promise<T> {
   return res.json() as Promise<T>;
 }
 
+interface BsddSearchApiResult {
+  uri?: string;
+  code?: string;
+  referenceCode?: string;
+  name?: string;
+  definition?: string | null;
+  dictionaryUri?: string;
+}
+
+function matchesIfcType(candidate: BsddSearchApiResult, ifcType: string): boolean {
+  return candidate.code === ifcType
+    || candidate.referenceCode === ifcType
+    || candidate.name === ifcType;
+}
+
+async function resolveFallbackClassUri(ifcType: string): Promise<string | null> {
+  try {
+    const raw = await fetchJson<{ classes?: BsddSearchApiResult[] }>(
+      `${BSDD_API}/api/Class/Search/v1?SearchText=${encodeURIComponent(ifcType)}&RelatedIfcEntities=${encodeURIComponent(ifcType)}`,
+    );
+    const classes = raw.classes ?? [];
+    if (classes.length === 0) return null;
+
+    const preferred = classes.find((entry) => entry.dictionaryUri === IFC_DICTIONARY_URI && matchesIfcType(entry, ifcType))
+      ?? classes.find((entry) => matchesIfcType(entry, ifcType))
+      ?? classes.find((entry) => entry.dictionaryUri === IFC_DICTIONARY_URI)
+      ?? classes[0];
+
+    return preferred?.uri ?? null;
+  } catch {
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -128,15 +162,30 @@ export function ifcClassUri(ifcType: string): string {
 export async function fetchClassInfo(
   ifcType: string,
 ): Promise<BsddClassInfo | null> {
-  const uri = ifcClassUri(ifcType);
+  const defaultUri = ifcClassUri(ifcType);
+  let uri = defaultUri;
   const cached = getCached(uri);
   if (cached) return cached;
 
   try {
     // Parameter names must be PascalCase per the bSDD OpenAPI spec
-    const raw = await fetchJson<Record<string, unknown>>(
-      `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
-    );
+    let raw: Record<string, unknown>;
+    try {
+      raw = await fetchJson<Record<string, unknown>>(
+        `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
+      );
+    } catch {
+      const fallbackUri = await resolveFallbackClassUri(ifcType);
+      if (!fallbackUri || fallbackUri === uri) {
+        throw new Error('bSDD class lookup failed');
+      }
+      uri = fallbackUri;
+      const fallbackCached = getCached(uri);
+      if (fallbackCached) return fallbackCached;
+      raw = await fetchJson<Record<string, unknown>>(
+        `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
+      );
+    }
 
     let info = mapClassResponse(raw, true);
 

package/src/services/cacheService.ts

@@ -71,7 +71,7 @@ let cacheService: ICacheService | null = null;
 export async function getCacheService(): Promise<ICacheService> {
   if (cacheService) return cacheService;
 
-  if (isTauri) {
+  if (isTauri()) {
     // Desktop: Use Tauri native filesystem
     const mod = await import('./desktop-cache.js');
     cacheService = {