@ifc-lite/viewer 1.21.0 → 1.22.0

package/src/lib/llm/models.ts

@@ -139,6 +139,20 @@ export const FREE_MODELS: LLMModel[] = rawFreeModels.map(applyCapabilities);
 // Requests go directly from the browser to the provider (no server proxy).
 
 const ANTHROPIC_BYOK_MODELS: LLMModel[] = [
+  {
+    id: 'claude-opus-4-7',
+    name: 'Claude Opus 4.7',
+    provider: 'Anthropic',
+    tier: 'byok',
+    source: 'anthropic',
+    contextWindow: 1_000_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$$$',
+    // Opus 4.7 returns 400 if temperature/top_p/top_k are present.
+    // See `whats-new-claude-4-7` docs § Sampling parameters removed.
+    acceptsSamplingParams: false,
+  },
   {
     id: 'claude-opus-4-6',
     name: 'Claude Opus 4.6',
@@ -175,6 +189,20 @@ const ANTHROPIC_BYOK_MODELS: LLMModel[] = [
 ];
 
 const OPENAI_BYOK_MODELS: LLMModel[] = [
+  {
+    id: 'gpt-5.5',
+    name: 'GPT-5.5',
+    provider: 'OpenAI',
+    tier: 'byok',
+    source: 'openai',
+    contextWindow: 1_000_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$$$',
+    // GPT-5 reasoning family only accepts the default temperature (1).
+    // Sending any other value returns 400 from /v1/chat/completions.
+    acceptsSamplingParams: false,
+  },
   {
     id: 'gpt-5.4',
     name: 'GPT-5.4',

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

@@ -15,6 +15,7 @@
 
 import Anthropic from '@anthropic-ai/sdk';
 import { readSseStream, type StreamMessage, type StreamOptions } from './stream-client.js';
+import { getModelById } from './models.js';
 
 const STREAM_REQUEST_TIMEOUT_MS = 45_000;
 
@@ -71,12 +72,19 @@ export async function streamAnthropicChat(
     dangerouslyAllowBrowser: true,
   });
 
+  // Opus 4.7+ returns 400 if `temperature` (or `top_p`/`top_k`) is present.
+  // We gate on the per-model `acceptsSamplingParams` flag in models.ts so
+  // future Claude models that adopt the same policy only need a flag bump,
+  // and Opus 4.6 / Sonnet 4.6 / Haiku 4.5 keep their tuned temperature.
+  const modelDef = getModelById(model);
+  const sendSamplingParams = modelDef?.acceptsSamplingParams !== false;
+
   let fullText = '';
   try {
     const stream = client.messages.stream({
       model,
       max_tokens: 8192,
-      temperature: 0.3,
+      ...(sendSamplingParams ? { temperature: 0.3 } : {}),
       system: system || undefined,
       messages: toAnthropicMessages(messages),
     });
@@ -118,8 +126,6 @@ export async function streamAnthropicChat(
 
 // ── OpenAI ─────────────────────────────────────────────────────────────────
 
-import { getModelById } from './models.js';
-
 /**
  * Stream an OpenAI model. Automatically picks the right API:
  * - Chat Completions (`/v1/chat/completions`) for standard chat models
@@ -147,13 +153,19 @@ async function streamOpenAiChatCompletions(
     ? [{ role: 'system', content: system }, ...messages]
     : [...messages];
 
+  // GPT-5 reasoning models (gpt-5.5, gpt-5.5-pro) only accept the default
+  // temperature; sending any other value returns 400. Mirror the Anthropic
+  // path: when the model is flagged `acceptsSamplingParams: false`, omit.
+  const modelDef = getModelById(model);
+  const sendSamplingParams = modelDef?.acceptsSamplingParams !== false;
+
   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,
+      ...(sendSamplingParams ? { temperature: 0.3 } : {}),
       max_completion_tokens: 8192,
     },
     apiKey,

package/src/lib/llm/types.ts

@@ -163,6 +163,14 @@ export interface LLMModel {
   cost?: ModelCost;
   /** OpenAI API variant: 'chat' (default) or 'responses' (Codex-style models) */
   openaiApi?: 'chat' | 'responses';
+  /**
+   * Whether the model accepts the classic sampling parameters (`temperature`,
+   * `top_p`, `top_k`). Default: true. Set to `false` for models that reject
+   * them (Anthropic Claude Opus 4.7 and later — see
+   * https://platform.claude.com/docs/en/about-claude/models/whats-new-claude-4-7).
+   * When `false`, the stream client omits these params from the request body.
+   */
+  acceptsSamplingParams?: boolean;
 }
 
 export type ChatStatus = 'idle' | 'sending' | 'streaming' | 'error';

package/src/services/playground-model.ts

@@ -0,0 +1,55 @@
+/* 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/. */
+
+/**
+ * Per-tab persistence for the model the /mcp/playground chat uses.
+ *
+ * The playground driver calls Anthropic's `messages.create` with the native
+ * tools API, so the selected model must be Anthropic. We keep a separate
+ * preference from the viewer's `chatActiveModel` so the two pages can default
+ * differently — the viewer often runs on a free proxy model, while playground
+ * users have already opted into BYOK by being here.
+ */
+
+import { getByokModelsForSource } from '@/lib/llm/models';
+
+const STORAGE_KEY = 'ifc-lite:playground-model:v1';
+const CHANGED_EVENT = 'ifc-lite:playground-model-changed';
+
+/**
+ * Default fallback when nothing is in storage. Sonnet hits the sweet spot for
+ * tool-calling agentic loops — fast enough for 25 sequential tool calls,
+ * smart enough to pick the right tool. Opus 4.7 is better at planning but
+ * costs ~3x; Haiku is faster but more likely to mis-pick tools.
+ */
+const FALLBACK_MODEL = 'claude-sonnet-4-6';
+
+function isValidAnthropicModel(id: string): boolean {
+  return getByokModelsForSource('anthropic').some((m) => m.id === id);
+}
+
+export function getPlaygroundModel(): string {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored && isValidAnthropicModel(stored)) return stored;
+  } catch {
+    /* localStorage blocked / quota-exceeded — fall through to default */
+  }
+  return FALLBACK_MODEL;
+}
+
+export function setPlaygroundModel(modelId: string): void {
+  if (!isValidAnthropicModel(modelId)) return;
+  try {
+    localStorage.setItem(STORAGE_KEY, modelId);
+  } catch {
+    /* storage write failed — selection only lives for this tab session */
+  }
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+}
+
+export function subscribePlaygroundModel(listener: () => void): () => void {
+  window.addEventListener(CHANGED_EVENT, listener);
+  return () => window.removeEventListener(CHANGED_EVENT, listener);
+}

package/src/store/index.ts

@@ -90,7 +90,7 @@ export type { ChatSlice } from './slices/chatSlice.js';
 export type { DesktopEntitlementSlice } from './slices/desktopEntitlementSlice.js';
 
 // Re-export Cesium types
-export type { CesiumSlice, CesiumDataSource } from './slices/cesiumSlice.js';
+export type { CesiumSlice, CesiumDataSource, CesiumPlacementDraft } from './slices/cesiumSlice.js';
 
 // Re-export Schedule (4D) types + selectors
 export type { ScheduleSlice, ScheduleTimeRange, GanttTimeScale } from './slices/scheduleSlice.js';
@@ -271,13 +271,12 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       cesiumAvailable: false,
       cesiumEnabled: false,
       cesiumTerrainHeight: null,
-      // Default the clamp toggle ON so models authored at sea-level
-      // OrthogonalHeight don't load buried below the 3D-tiles terrain on
-      // first activation. Users can still uncheck it manually.
-      cesiumTerrainClamp: true,
       cesiumSourceModelId: null,
       cesiumTerrainClipY: null,
       cesiumGlbLoaded: false,
+      cesiumPlacementEditMode: false,
+      cesiumPlacementDraftModelId: null,
+      cesiumPlacementDraft: null,
 
       // Drawing 2D
       drawing2D: null,

package/src/store/slices/cesiumSlice.ts

@@ -15,11 +15,19 @@
  */
 
 import type { StateCreator } from 'zustand';
+import type { MapConversion } from '@ifc-lite/parser';
 
-export type CesiumDataSource =
-  | 'osm-buildings'        // Cesium OSM Buildings (free via Cesium ion)
-  | 'bing-aerial'          // Bing Maps aerial imagery draped on terrain
-  | 'google-photorealistic'; // Google Photorealistic 3D Tiles (requires API key)
+import { clearTerrainElevationCache } from '@/lib/geo/terrain-elevation';
+
+export type CesiumDataSource = 'google-photorealistic';
+
+export interface CesiumPlacementDraft {
+  eastings: number;
+  northings: number;
+  orthogonalHeight: number;
+  xAxisAbscissa: number;
+  xAxisOrdinate: number;
+}
 
 export interface CesiumSlice {
   // State
@@ -31,16 +39,22 @@ export interface CesiumSlice {
   cesiumIonToken: string;
   /** Terrain enabled (Cesium World Terrain). */
   cesiumTerrainEnabled: boolean;
-  /** Clamp model to terrain height at its geodetic position. */
-  cesiumTerrainClamp: boolean;
   /** Terrain height at model position (queried from Cesium, meters). null = not yet queried. */
   cesiumTerrainHeight: number | null;
+  /** Human-readable source label for the sampled terrain height. */
+  cesiumTerrainSource: string | null;
   /** Model ID that the Cesium overlay is currently displaying. */
   cesiumSourceModelId: string | null;
   /** Terrain clip Y position in viewer space. When set, fragments below this Y are discarded. */
   cesiumTerrainClipY: number | null;
   /** Whether the GLB model has been loaded into Cesium (hides WebGPU overlay). */
   cesiumGlbLoaded: boolean;
+  /** Whether the direct placement editor is active. */
+  cesiumPlacementEditMode: boolean;
+  /** Source model currently associated with the placement draft. */
+  cesiumPlacementDraftModelId: string | null;
+  /** Preview placement values shown in Cesium before applying to IFC georeference. */
+  cesiumPlacementDraft: CesiumPlacementDraft | null;
 
   // Actions
   setCesiumAvailable: (available: boolean) => void;
@@ -49,11 +63,19 @@ export interface CesiumSlice {
   setCesiumDataSource: (source: CesiumDataSource) => void;
   setCesiumIonToken: (token: string) => void;
   setCesiumTerrainEnabled: (enabled: boolean) => void;
-  setCesiumTerrainClamp: (clamp: boolean) => void;
   setCesiumTerrainHeight: (height: number | null) => void;
+  setCesiumTerrainSource: (source: string | null) => void;
   setCesiumSourceModelId: (modelId: string | null) => void;
   setCesiumTerrainClipY: (y: number | null) => void;
   setCesiumGlbLoaded: (loaded: boolean) => void;
+  setCesiumPlacementEditMode: (enabled: boolean) => void;
+  toggleCesiumPlacementEditMode: () => void;
+  beginCesiumPlacementDraft: (
+    modelId: string,
+    conversion: Pick<MapConversion, 'eastings' | 'northings' | 'orthogonalHeight' | 'xAxisAbscissa' | 'xAxisOrdinate'>,
+  ) => void;
+  updateCesiumPlacementDraft: (values: Partial<CesiumPlacementDraft>) => void;
+  resetCesiumPlacementDraft: () => void;
 }
 
 const STORAGE_KEY_ION_TOKEN = 'ifc-lite:cesium-ion-token';
@@ -80,13 +102,9 @@ function saveToStorage(key: string, value: string): void {
   } catch { /* storage unavailable */ }
 }
 
-const VALID_DATA_SOURCES = new Set<CesiumDataSource>(['osm-buildings', 'bing-aerial', 'google-photorealistic']);
-
 function loadDataSource(): CesiumDataSource {
-  const stored = loadFromStorage(STORAGE_KEY_DATA_SOURCE, '');
-  return VALID_DATA_SOURCES.has(stored as CesiumDataSource)
-    ? (stored as CesiumDataSource)
-    : 'google-photorealistic';
+  // Only Google Photorealistic is supported; upgrade any stale stored value.
+  return 'google-photorealistic';
 }
 
 /** Resolve the Cesium ion token: user override > build-time default */
@@ -101,27 +119,90 @@ export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> =
   cesiumDataSource: loadDataSource(),
   cesiumIonToken: resolveIonToken(),
   cesiumTerrainEnabled: true,
-  cesiumTerrainClamp: true,
   cesiumTerrainHeight: null,
+  cesiumTerrainSource: null,
   cesiumSourceModelId: null,
   cesiumTerrainClipY: null,
   cesiumGlbLoaded: false,
+  cesiumPlacementEditMode: false,
+  cesiumPlacementDraftModelId: null,
+  cesiumPlacementDraft: null,
 
   setCesiumAvailable: (available) => set({ cesiumAvailable: available }),
   setCesiumEnabled: (enabled) => set({ cesiumEnabled: enabled }),
-  toggleCesium: () => set((s) => ({ cesiumEnabled: !s.cesiumEnabled })),
+  toggleCesium: () => set((s) => ({
+    cesiumEnabled: !s.cesiumEnabled,
+    ...(s.cesiumEnabled
+      ? {
+          cesiumPlacementEditMode: false,
+          cesiumPlacementDraftModelId: null,
+          cesiumPlacementDraft: null,
+        }
+      : {}),
+  })),
   setCesiumDataSource: (source) => {
+    clearTerrainElevationCache();
     saveToStorage(STORAGE_KEY_DATA_SOURCE, source);
-    set({ cesiumDataSource: source });
+    set({
+      cesiumDataSource: source,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
   },
   setCesiumIonToken: (token) => {
+    clearTerrainElevationCache();
     saveToStorage(STORAGE_KEY_ION_TOKEN, token);
-    set({ cesiumIonToken: token || DEFAULT_ION_TOKEN });
+    set({
+      cesiumIonToken: token || DEFAULT_ION_TOKEN,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
+  },
+  setCesiumTerrainEnabled: (enabled) => {
+    clearTerrainElevationCache();
+    set({
+      cesiumTerrainEnabled: enabled,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
   },
-  setCesiumTerrainEnabled: (enabled) => set({ cesiumTerrainEnabled: enabled }),
-  setCesiumTerrainClamp: (clamp) => set({ cesiumTerrainClamp: clamp }),
   setCesiumTerrainHeight: (height) => set({ cesiumTerrainHeight: height }),
+  setCesiumTerrainSource: (source) => set({ cesiumTerrainSource: source }),
   setCesiumSourceModelId: (modelId) => set({ cesiumSourceModelId: modelId }),
   setCesiumTerrainClipY: (y) => set({ cesiumTerrainClipY: y }),
   setCesiumGlbLoaded: (loaded) => set({ cesiumGlbLoaded: loaded }),
+  setCesiumPlacementEditMode: (enabled) => set({ cesiumPlacementEditMode: enabled }),
+  toggleCesiumPlacementEditMode: () => set((s) => ({
+    cesiumPlacementEditMode: !s.cesiumPlacementEditMode,
+    ...(!s.cesiumPlacementEditMode
+      ? {}
+      : {
+          cesiumPlacementDraftModelId: null,
+          cesiumPlacementDraft: null,
+        }),
+  })),
+  beginCesiumPlacementDraft: (modelId, conversion) => set({
+    cesiumPlacementDraftModelId: modelId,
+    cesiumPlacementDraft: {
+      eastings: conversion.eastings,
+      northings: conversion.northings,
+      orthogonalHeight: conversion.orthogonalHeight,
+      // IFC MapConversion's x-axis cos/sin pair is optional in the schema.
+      // When absent, the convention is "no rotation": cos=1, sin=0.
+      xAxisAbscissa: conversion.xAxisAbscissa ?? 1,
+      xAxisOrdinate: conversion.xAxisOrdinate ?? 0,
+    },
+  }),
+  updateCesiumPlacementDraft: (values) => set((state) => ({
+    cesiumPlacementDraft: state.cesiumPlacementDraft
+      ? { ...state.cesiumPlacementDraft, ...values }
+      : null,
+  })),
+  resetCesiumPlacementDraft: () => set({
+    cesiumPlacementDraftModelId: null,
+    cesiumPlacementDraft: null,
+  }),
 });

package/src/store.ts

@@ -64,6 +64,9 @@ export { customPlaneCenter } from './store/slices/sectionSlice.js';
 export { loadLastSectionMode } from './store/slices/sectionSlice.js';
 export type { LastSectionMode } from './store/slices/sectionSlice.js';
 
+// Re-export Cesium placement types for backwards-compatible '@/store' imports.
+export type { CesiumPlacementDraft } from './store/slices/cesiumSlice.js';
+
 // Re-export Schedule (4D) types + helpers
 export type { ScheduleSlice, ScheduleTimeRange, GanttTimeScale } from './store/slices/scheduleSlice.js';
 export {