@ifc-lite/viewer 1.14.2 → 1.14.4

package/src/lib/llm/context-builder.ts

@@ -0,0 +1,305 @@
+/* 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/. */
+
+/**
+ * Build model context from the current viewer state.
+ * This context is injected into the system prompt so the LLM
+ * knows what's currently loaded in the 3D viewer.
+ */
+
+import { useViewerStore } from '@/store';
+import type { ModelContext } from './system-prompt.js';
+import { IfcTypeEnum, type SpatialNode, type SpatialHierarchy } from '@ifc-lite/data';
+import {
+  extractClassificationsOnDemand,
+  extractMaterialsOnDemand,
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  extractTypeEntityOwnProperties,
+  extractTypePropertiesOnDemand,
+} from '@ifc-lite/parser';
+import { resolveEntityRef } from '@/store/resolveEntityRef';
+
+let cachedTypeCountsFingerprint = '';
+let cachedTypeCounts: Record<string, number> = {};
+
+function buildFingerprint(state: ReturnType<typeof useViewerStore.getState>): string {
+  if (state.models.size > 0) {
+    const items: string[] = [];
+    for (const [id, model] of state.models) {
+      const count = model.ifcDataStore?.entities.count ?? 0;
+      items.push(`${id}:${count}`);
+    }
+    items.sort();
+    return `federated|${items.join('|')}`;
+  }
+
+  const legacyCount = state.ifcDataStore?.entities.count ?? 0;
+  return `legacy|${legacyCount}`;
+}
+
+function computeTypeCounts(state: ReturnType<typeof useViewerStore.getState>): Record<string, number> {
+  const typeCounts: Record<string, number> = {};
+
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const store = model.ifcDataStore;
+      if (!store) continue;
+      for (let i = 0; i < store.entities.count; i++) {
+        const id = store.entities.expressId[i];
+        const type = store.entities.getTypeName(id);
+        if (type) typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+      }
+    }
+    return typeCounts;
+  }
+
+  if (state.ifcDataStore) {
+    const store = state.ifcDataStore;
+    for (let i = 0; i < store.entities.count; i++) {
+      const id = store.entities.expressId[i];
+      const type = store.entities.getTypeName(id);
+      if (type) typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+    }
+  }
+
+  return typeCounts;
+}
+
+function collectStoreys(
+  hierarchy: SpatialHierarchy | undefined,
+  modelName?: string,
+): NonNullable<ModelContext['storeys']> {
+  if (!hierarchy?.project) return [];
+
+  const result: NonNullable<ModelContext['storeys']> = [];
+  const visit = (node: SpatialNode) => {
+    if (node.type === IfcTypeEnum.IfcBuildingStorey) {
+      result.push({
+        modelName,
+        name: node.name || 'Storey',
+        elevation: node.elevation ?? hierarchy.storeyElevations.get(node.expressId) ?? 0,
+        height: hierarchy.storeyHeights.get(node.expressId),
+        elementCount: hierarchy.byStorey.get(node.expressId)?.length ?? node.elements.length,
+      });
+    }
+    for (const child of node.children) visit(child);
+  };
+
+  visit(hierarchy.project);
+  result.sort((a, b) => a.elevation - b.elevation);
+  return result;
+}
+
+function getStoreForModel(
+  state: ReturnType<typeof useViewerStore.getState>,
+  modelId: string,
+): { store: NonNullable<typeof state.ifcDataStore> | null; modelName?: string } {
+  if (modelId === 'legacy') {
+    return { store: state.ifcDataStore, modelName: 'Model' };
+  }
+  const model = state.models.get(modelId);
+  return { store: model?.ifcDataStore ?? null, modelName: model?.name ?? modelId };
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return Array.from(new Set(values.filter((value): value is string => Boolean(value))));
+}
+
+function collectSelectedEntities(state: ReturnType<typeof useViewerStore.getState>): NonNullable<ModelContext['selectedEntities']> {
+  const refs = state.selectedEntities.length > 0
+    ? state.selectedEntities
+    : state.selectedEntity
+      ? [state.selectedEntity]
+      : state.selectedEntityIds.size > 0
+        ? Array.from(state.selectedEntityIds).slice(0, 5).map((id) => resolveEntityRef(id))
+        : [];
+
+  return refs.slice(0, 5).flatMap((ref) => {
+    const { store, modelName } = getStoreForModel(state, ref.modelId);
+    if (!store) return [];
+
+    const type = store.entities.getTypeName(ref.expressId) || 'Unknown';
+    const name = store.entities.getName(ref.expressId) || `${type} #${ref.expressId}`;
+    const storeyId = store.spatialHierarchy?.elementToStorey.get(ref.expressId);
+    const storeyName = storeyId !== undefined ? (store.entities.getName(storeyId) || `Storey #${storeyId}`) : undefined;
+    const storeyElevation = storeyId !== undefined ? store.spatialHierarchy?.storeyElevations.get(storeyId) : undefined;
+
+    const rawPsets = extractPropertiesOnDemand(store, ref.expressId) as Array<{ name?: string; Name?: string }> | undefined;
+    const rawQsets = extractQuantitiesOnDemand(store, ref.expressId) as Array<{ name?: string; Name?: string }> | undefined;
+    const typeOwnPsets = extractTypeEntityOwnProperties(store, ref.expressId);
+    const inheritedTypeProps = extractTypePropertiesOnDemand(store, ref.expressId);
+    const rawMaterial = extractMaterialsOnDemand(store, ref.expressId);
+    const rawClassifications = extractClassificationsOnDemand(store, ref.expressId);
+    const instancePropertySets = uniqueStrings((rawPsets ?? []).map((pset) => pset.name ?? pset.Name));
+    const ownTypePropertySets = uniqueStrings(typeOwnPsets.map((pset) => pset.name));
+    const inheritedTypePropertySets = uniqueStrings((inheritedTypeProps?.properties ?? []).map((pset) => pset.name));
+    const selectionKind = ownTypePropertySets.length > 0 ? 'type' : 'occurrence';
+    const propertySets = (selectionKind === 'type' ? ownTypePropertySets : instancePropertySets).slice(0, 6);
+    const typePropertySets = (selectionKind === 'type' ? [] : inheritedTypePropertySets).slice(0, 6);
+    const quantitySets = (rawQsets ?? []).map((qset) => qset.name ?? qset.Name).filter((value): value is string => Boolean(value)).slice(0, 6);
+    const materialName = rawMaterial?.name ?? rawMaterial?.materials?.[0];
+    const classifications = rawClassifications
+      .map((classification) => classification.identification ?? classification.name ?? classification.system)
+      .filter((value): value is string => Boolean(value))
+      .slice(0, 4);
+
+    return [{
+      modelName,
+      name,
+      type,
+      selectionKind,
+      globalId: store.entities.getGlobalId?.(ref.expressId),
+      storeyName,
+      storeyElevation,
+      propertySets,
+      typePropertySets,
+      quantitySets,
+      materialName,
+      classifications,
+    }];
+  });
+}
+
+/**
+ * Snapshot the current model context from the Zustand store.
+ * Called before each LLM request to provide up-to-date context.
+ */
+export function getModelContext(): ModelContext {
+  const state = useViewerStore.getState();
+
+  const models: ModelContext['models'] = [];
+  const storeys: NonNullable<ModelContext['storeys']> = [];
+  const fingerprint = buildFingerprint(state);
+
+  // Federated models
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const entityCount = model.ifcDataStore?.entities.count ?? 0;
+      models.push({
+        name: model.name ?? 'Unknown',
+        entityCount,
+      });
+      storeys.push(...collectStoreys(model.ifcDataStore?.spatialHierarchy, model.name ?? 'Unknown'));
+    }
+  }
+
+  // Legacy single-model path
+  if (models.length === 0 && state.ifcDataStore) {
+    const store = state.ifcDataStore;
+    models.push({
+      name: 'Model',
+      entityCount: store.entities.count,
+    });
+    storeys.push(...collectStoreys(store.spatialHierarchy, 'Model'));
+  }
+
+  if (fingerprint !== cachedTypeCountsFingerprint) {
+    cachedTypeCounts = computeTypeCounts(state);
+    cachedTypeCountsFingerprint = fingerprint;
+  }
+
+  // Selection count
+  const selectedCount = state.selectedEntities.length > 0
+    ? state.selectedEntities.length
+    : state.selectedEntitiesSet.size > 0
+      ? state.selectedEntitiesSet.size
+      : state.selectedEntity
+        ? 1
+        : state.selectedEntityIds.size > 0
+          ? state.selectedEntityIds.size
+          : state.selectedEntityId !== null ? 1 : 0;
+  const selectedEntities = collectSelectedEntities(state);
+
+  return { models, typeCounts: cachedTypeCounts, selectedCount, storeys, selectedEntities };
+}
+
+/**
+ * Parse a CSV string into an array of row objects.
+ * Simple parser that handles quoted fields with commas.
+ */
+export function parseCSV(text: string): { columns: string[]; rows: Record<string, string>[] } {
+  const records = splitCSVRecords(text).filter((record) => record.trim().length > 0);
+  if (records.length === 0) return { columns: [], rows: [] };
+
+  // Parse header
+  const columns = parseCSVLine(records[0]);
+
+  // Parse rows
+  const rows: Record<string, string>[] = [];
+  for (let i = 1; i < records.length; i++) {
+    const values = parseCSVLine(records[i]);
+    const row: Record<string, string> = {};
+    for (let j = 0; j < columns.length; j++) {
+      row[columns[j]] = values[j] ?? '';
+    }
+    rows.push(row);
+  }
+
+  return { columns, rows };
+}
+
+function splitCSVRecords(text: string): string[] {
+  const normalized = text.replace(/\r\n?/g, '\n');
+  const records: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized[i];
+    if (char === '"') {
+      if (inQuotes && normalized[i + 1] === '"') {
+        current += '""';
+        i++;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (char === '\n' && !inQuotes) {
+      records.push(current);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+
+  if (current.length > 0) {
+    records.push(current);
+  }
+  return records;
+}
+
+/** Parse a single CSV line, handling quoted fields */
+function parseCSVLine(line: string): string[] {
+  const fields: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+      } else if (char === ',' || char === ';') {
+        fields.push(current.trim());
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+  }
+  fields.push(current.trim());
+  return fields;
+}

package/src/lib/llm/free-models.test.ts

@@ -0,0 +1,118 @@
+/* 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 test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import type { LLMModel } from './types.js';
+
+const viewerEnvUrl = new URL('../../../.env.local', import.meta.url);
+const VERIFY_OPENROUTER_MODELS = process.env.IFC_LITE_VERIFY_OPENROUTER_MODELS === '1';
+
+function parseEnvValue(envText: string, key: string): string {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = envText.match(new RegExp(`^${escapedKey}=(.*)$`, 'm'));
+  return match?.[1]?.trim() ?? '';
+}
+
+function parseCsvList(raw: string): string[] {
+  if (!raw) return [];
+  return raw
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+async function readConfiguredFreeModels(): Promise<string[] | null> {
+  const envOverride = process.env.VITE_LLM_FREE_MODELS ?? process.env.LLM_FREE_MODELS;
+  if (typeof envOverride === 'string' && envOverride.trim().length > 0) {
+    return parseCsvList(envOverride);
+  }
+
+  try {
+    const envText = await readFile(viewerEnvUrl, 'utf8');
+    const configuredFreeModels = parseCsvList(parseEnvValue(envText, 'VITE_LLM_FREE_MODELS'));
+    return configuredFreeModels.length > 0 ? configuredFreeModels : null;
+  } catch {
+    return null;
+  }
+}
+
+test('registry free models match configured env list', async (t) => {
+  const configuredFreeModels = await readConfiguredFreeModels();
+  if (!configuredFreeModels) {
+    t.skip('Viewer LLM env is not configured in this environment.');
+    return;
+  }
+
+  process.env.VITE_LLM_FREE_MODELS = configuredFreeModels.join(',');
+  process.env.VITE_LLM_PRO_MODELS_LOW = '';
+  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
+  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
+  process.env.VITE_LLM_IMAGE_MODELS = '';
+  process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = '';
+
+  const { FREE_MODELS } = await import(`./models.ts?ts=${Date.now()}`) as { FREE_MODELS: LLMModel[] };
+  assert.deepEqual(
+    FREE_MODELS.map((model) => model.id),
+    configuredFreeModels,
+    'FREE_MODELS must follow VITE_LLM_FREE_MODELS order and values',
+  );
+});
+
+test('model capabilities follow override env lists', async () => {
+  process.env.VITE_LLM_FREE_MODELS = 'qwen/qwen3-coder,mistralai/devstral-2512';
+  process.env.VITE_LLM_PRO_MODELS_LOW = '';
+  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
+  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
+  process.env.VITE_LLM_IMAGE_MODELS = 'mistralai/devstral-2512';
+  process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = 'qwen/qwen3-coder';
+
+  const { ALL_MODELS } = await import(`./models.ts?ts=${Date.now()}`) as { ALL_MODELS: LLMModel[] };
+  const qwen = ALL_MODELS.find((m) => m.id === 'qwen/qwen3-coder');
+  const devstral = ALL_MODELS.find((m) => m.id === 'mistralai/devstral-2512');
+
+  assert.ok(qwen, 'Expected qwen model in registry');
+  assert.ok(devstral, 'Expected devstral model in registry');
+  assert.equal(qwen.supportsImages, false);
+  assert.equal(qwen.supportsFileAttachments, true);
+  assert.equal(devstral.supportsImages, true);
+  assert.equal(devstral.supportsFileAttachments, false);
+});
+
+test('each configured free model exists in OpenRouter catalog', async (t) => {
+  if (!VERIFY_OPENROUTER_MODELS) {
+    t.skip('Set IFC_LITE_VERIFY_OPENROUTER_MODELS=1 to run the live OpenRouter catalog check.');
+    return;
+  }
+
+  const configuredFreeModels = await readConfiguredFreeModels();
+  if (!configuredFreeModels) {
+    t.skip('Viewer LLM env is not configured in this environment.');
+    return;
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 10_000);
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models', { signal: controller.signal });
+    assert.equal(response.ok, true, `OpenRouter models API failed with HTTP ${response.status}`);
+
+    const payload = await response.json() as { data?: Array<{ id?: string }> };
+    const modelIdSet = new Set(
+      Array.isArray(payload.data)
+        ? payload.data.map((model) => model.id).filter((id): id is string => typeof id === 'string')
+        : [],
+    );
+
+    const missing = configuredFreeModels.filter((id) => !modelIdSet.has(id));
+    assert.deepEqual(
+      missing,
+      [],
+      `Configured free model IDs missing from OpenRouter catalog: ${missing.join(', ')}`,
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+});

package/src/lib/llm/message-capabilities.test.ts

@@ -0,0 +1,131 @@
+/* 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 test from 'node:test';
+import assert from 'node:assert/strict';
+import type { ChatMessage, FileAttachment } from './types.js';
+import { buildStreamMessagesForModel, filterAttachmentsForModel } from './message-capabilities.js';
+
+function makeImageAttachment(name: string): FileAttachment {
+  return {
+    id: `img:${name}`,
+    name,
+    type: 'image/png',
+    size: 100,
+    imageBase64: 'data:image/png;base64,abc',
+    isImage: true,
+  };
+}
+
+function makeFileAttachment(name: string): FileAttachment {
+  return {
+    id: `file:${name}`,
+    name,
+    type: 'text/csv',
+    size: 20,
+    textContent: 'a,b\n1,2',
+  };
+}
+
+test('filters attachments by model capabilities', () => {
+  const attachments = [makeImageAttachment('img.png'), makeFileAttachment('data.csv')];
+  const filtered = filterAttachmentsForModel(attachments, false, true);
+
+  assert.equal(filtered.accepted.length, 1);
+  assert.equal(filtered.accepted[0].name, 'data.csv');
+  assert.equal(filtered.droppedImages, 1);
+  assert.equal(filtered.droppedFiles, 0);
+});
+
+test('buildStreamMessagesForModel drops unsupported image payload parts', () => {
+  const messages: ChatMessage[] = [
+    {
+      id: 'm1',
+      role: 'user',
+      content: 'Hello',
+      createdAt: Date.now(),
+      attachments: [makeImageAttachment('img1.png')],
+    },
+  ];
+
+  const result = buildStreamMessagesForModel(messages, 'data:image/png;base64,viewport', false);
+  assert.equal(result.droppedInlineImages, 1);
+  assert.equal(result.droppedViewportScreenshot, true);
+  assert.equal(typeof result.messages[0].content, 'string');
+  assert.equal(result.messages[0].content, 'Hello');
+});
+
+test('buildStreamMessagesForModel keeps image payload parts when supported', () => {
+  const messages: ChatMessage[] = [
+    {
+      id: 'm1',
+      role: 'user',
+      content: 'Show this',
+      createdAt: Date.now(),
+      attachments: [makeImageAttachment('img1.png')],
+    },
+  ];
+
+  const result = buildStreamMessagesForModel(messages, null, true);
+  assert.equal(result.droppedInlineImages, 0);
+  assert.equal(result.droppedViewportScreenshot, false);
+  assert.ok(Array.isArray(result.messages[0].content));
+  const parts = result.messages[0].content as Array<{ type: string }>;
+  assert.equal(parts[0].type, 'image_url');
+});
+
+test('buildStreamMessagesForModel keeps historical turns text-only', () => {
+  const messages: ChatMessage[] = [
+    {
+      id: 'm0',
+      role: 'user',
+      content: 'Earlier image',
+      createdAt: Date.now() - 1000,
+      attachments: [makeImageAttachment('old.png')],
+    },
+    {
+      id: 'm1',
+      role: 'user',
+      content: 'Latest image',
+      createdAt: Date.now(),
+      attachments: [makeImageAttachment('new.png')],
+    },
+  ];
+
+  const result = buildStreamMessagesForModel(messages, null, true);
+  assert.equal(typeof result.messages[0].content, 'string');
+  assert.equal(result.messages[0].content, 'Earlier image');
+  assert.ok(Array.isArray(result.messages[1].content));
+  const latestParts = result.messages[1].content as Array<{ type: string }>;
+  assert.equal(latestParts[0].type, 'image_url');
+});
+
+test('buildStreamMessagesForModel attaches viewport screenshot only to latest turn', () => {
+  const messages: ChatMessage[] = [
+    {
+      id: 'm0',
+      role: 'user',
+      content: 'Earlier question',
+      createdAt: Date.now() - 1000,
+    },
+    {
+      id: 'm1',
+      role: 'user',
+      content: 'Current question',
+      createdAt: Date.now(),
+    },
+  ];
+
+  const result = buildStreamMessagesForModel(messages, 'data:image/jpeg;base64,current', true);
+
+  // Earlier turn remains plain text.
+  assert.equal(typeof result.messages[0].content, 'string');
+  assert.equal(result.messages[0].content, 'Earlier question');
+
+  // Latest turn gets exactly one screenshot image part.
+  assert.ok(Array.isArray(result.messages[1].content));
+  const parts = result.messages[1].content as Array<{ type: string }>;
+  const imageParts = parts.filter((p) => p.type === 'image_url');
+  assert.equal(imageParts.length, 1);
+});

package/src/lib/llm/message-capabilities.ts

@@ -0,0 +1,94 @@
+/* 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 { FileAttachment, ChatMessage } from './types.js';
+import type { StreamMessage, TextContentPart, ImageContentPart } from './stream-client.js';
+
+export interface AttachmentFilterResult {
+  accepted: FileAttachment[];
+  droppedImages: number;
+  droppedFiles: number;
+}
+
+export interface StreamBuildResult {
+  messages: StreamMessage[];
+  droppedInlineImages: number;
+  droppedViewportScreenshot: boolean;
+}
+
+export function filterAttachmentsForModel(
+  attachments: FileAttachment[],
+  supportsImages: boolean,
+  supportsFileAttachments: boolean,
+): AttachmentFilterResult {
+  const accepted: FileAttachment[] = [];
+  let droppedImages = 0;
+  let droppedFiles = 0;
+
+  for (const attachment of attachments) {
+    if (attachment.isImage && attachment.imageBase64) {
+      if (supportsImages) {
+        accepted.push(attachment);
+      } else {
+        droppedImages += 1;
+      }
+      continue;
+    }
+
+    if (supportsFileAttachments) {
+      accepted.push(attachment);
+    } else {
+      droppedFiles += 1;
+    }
+  }
+
+  return { accepted, droppedImages, droppedFiles };
+}
+
+export function buildStreamMessagesForModel(
+  allMessages: ChatMessage[],
+  viewportScreenshot: string | null,
+  supportsImages: boolean,
+): StreamBuildResult {
+  let droppedInlineImages = 0;
+  let droppedViewportScreenshot = false;
+
+  const messages = allMessages.map((message, idx) => {
+    const isLastMessage = idx === allMessages.length - 1;
+    // Only include binary image payloads for the most recent message.
+    // Older turns keep text-only content to avoid unbounded request growth.
+    const imageAttachments = isLastMessage
+      ? (message.attachments?.filter((a) => a.isImage && a.imageBase64) ?? [])
+      : [];
+    const hasViewportShot = isLastMessage && Boolean(viewportScreenshot);
+
+    if (!supportsImages) {
+      const originalImageCount = message.attachments?.filter((a) => a.isImage && a.imageBase64).length ?? 0;
+      droppedInlineImages += originalImageCount;
+      droppedViewportScreenshot = droppedViewportScreenshot || hasViewportShot;
+      return { role: message.role as 'user' | 'assistant', content: message.content };
+    }
+
+    if (imageAttachments.length === 0 && !hasViewportShot) {
+      return { role: message.role as 'user' | 'assistant', content: message.content };
+    }
+
+    const parts: Array<TextContentPart | ImageContentPart> = [];
+    for (const img of imageAttachments) {
+      parts.push({ type: 'image_url', image_url: { url: img.imageBase64! } });
+    }
+    if (hasViewportShot) {
+      parts.push({ type: 'image_url', image_url: { url: viewportScreenshot! } });
+      parts.push({
+        type: 'text',
+        text: `${message.content}\n\n[Attached: current viewport screenshot showing the 3D model state]`,
+      });
+    } else {
+      parts.push({ type: 'text', text: message.content });
+    }
+    return { role: message.role as 'user' | 'assistant', content: parts };
+  });
+
+  return { messages, droppedInlineImages, droppedViewportScreenshot };
+}