@ifc-lite/viewer 1.17.4 → 1.18.0

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/system-prompt.test.ts

@@ -91,6 +91,20 @@ test('system prompt includes selected entity IFC context when provided', () => {
   assert.match(prompt, /Selected entities: Tower: IfcCurtainWall "Facade Panel A", kind=occurrence, storey=Level 10@31.5m, psets=Pset_CurtainWallCommon, typePsets=Pset_CurtainWallTypeCommon, qsets=Qto_CurtainWallBaseQuantities, material=Aluminium, classifications=A-123 \| Tower: IfcWallType "Exterior Wall Type", kind=type, psets=Pset_WallCommon, classifications=A-WALL/);
 });
 
+test('system prompt includes the BIM.STORE cheat sheet and routing rule', () => {
+  const prompt = buildSystemPrompt();
+
+  // Section heading + the three method examples
+  assert.match(prompt, /## BIM\.STORE CHEAT SHEET/);
+  assert.match(prompt, /bim\.store\.setPositionalAttribute\(profile, 3, 0\.6\)/);
+  assert.match(prompt, /bim\.store\.addEntity\("arch"/);
+  assert.match(prompt, /bim\.store\.removeEntity\(unwantedRef\)/);
+
+  // Routing rule disambiguating store / mutate / create
+  assert.match(prompt, /bim\.store\.setPositionalAttribute\(entity, index, value\)`? for positional STEP-argument edits/);
+  assert.match(prompt, /Do NOT use `bim\.create` for these/);
+});
+
 test('system prompt includes method-specific create contract guidance', () => {
   const prompt = buildSystemPrompt();
   assert.match(prompt, /BIM\.CREATE CONTRACT CHEAT SHEET/);

package/src/lib/llm/system-prompt.ts

@@ -100,6 +100,69 @@ function buildIntentMethodSection(intent: LlmTaskIntent): string {
   return lines.join('\n');
 }
 
+function buildStoreCheatSheet(): string {
+  const storeNamespace = NAMESPACE_SCHEMAS.find((schema) => schema.name === 'store');
+  if (!storeNamespace) return '';
+
+  return [
+    '## BIM.STORE CHEAT SHEET',
+    '`bim.store.*` edits a parsed model in place — use it when the user already has',
+    'a model loaded and wants raw STEP-level edits, NOT when building a new model from',
+    'scratch (that\'s `bim.create`).',
+    '',
+    '- `addEntity(modelId, { type, attributes })` — inject a STEP entity. `attributes`',
+    '  follows EntityExtractor output: numbers → REAL/integer, `"#42"` → ref, `".AREA."` → enum,',
+    '  `null` → `$`, arrays → STEP list. Returns `{ modelId, expressId }`.',
+    '- `removeEntity(entity)` — tombstones existing source entities or forgets overlay-only ones.',
+    '- `setPositionalAttribute(entity, index, value)` — edit a non-IfcRoot attribute by',
+    '  zero-based STEP argument index. Use this for `IfcRectangleProfileDef.XDim` (index 3),',
+    '  `YDim` (index 4), `IfcCartesianPoint.Coordinates` (index 0), etc. Use `bim.mutate.setAttribute`',
+    '  for IfcRoot attributes (Name, Description, ObjectType, Tag).',
+    '- High-level builders anchor a new element to an existing IfcBuildingStorey:',
+    '    `addColumn(modelId, storeyId, { Position, Width, Depth, Height })`',
+    '    `addWall(modelId, storeyId, { Start, End, Thickness, Height })`',
+    '    `addBeam(modelId, storeyId, { Start, End, Width, Height })`',
+    '    `addSlab(modelId, storeyId, { Position, Width, Depth, Thickness })`             // rectangle',
+    '    `addSlab(modelId, storeyId, { Profile: "polygon", OuterCurve: [[x,y],…], Thickness })`',
+    '    `addRoof(modelId, storeyId, { … same shape as addSlab — emits .FLAT_ROOF. })`',
+    '    `addPlate(modelId, storeyId, { … same shape as addSlab — IfcPlate, PredefinedType? })`',
+    '    `addSpace(modelId, storeyId, { Position, Width, Depth, Height, LongName? })`     // room rectangle',
+    '    `addSpace(modelId, storeyId, { Profile: "polygon", OuterCurve, Height })`        // room polygon',
+    '    `addDoor(modelId, storeyId, { Position, Width, Height, FrameThickness?, OperationType? })`',
+    '    `addWindow(modelId, storeyId, { Position, Width, Height, FrameThickness?, PartitioningType? })`',
+    '    `addMember(modelId, storeyId, { Start, End, Width, Height, PredefinedType? })`   // brace/post/strut',
+    '  Each emits ~12 STEP entities (placement chain → profile → solid → representation +',
+    '  IfcRelContainedInSpatialStructure, except `addSpace` which uses IfcRelAggregates).',
+    '  Coords are storey-local metres. Polygon outlines need ≥3 points; the polyline is auto-closed.',
+    '- Edits accumulate in an overlay; they show up after `bim.export.ifc(bim.query.all())`',
+    '  or when the viewer next renders. Use `bim.mutate.undo(modelId)` to roll back.',
+    '',
+    'Canonical examples:',
+    '```js',
+    '// Resize a rectangular profile from 0.3×0.4 to 0.6×0.4',
+    'const profile = bim.query.byId("arch", 35);',
+    'bim.store.setPositionalAttribute(profile, 3, 0.6);   // XDim',
+    '',
+    '// Drop a wall on the first storey',
+    'const storeyId = bim.query.byType("IfcBuildingStorey")[0].ref.expressId;',
+    'bim.store.addWall("arch", storeyId, {',
+    '  Start: [0, 0, 0], End: [5, 0, 0],',
+    '  Thickness: 0.2, Height: 3, Name: "North Wall",',
+    '});',
+    '',
+    '// Add a custom IfcCartesianPoint, then reference it from another entity',
+    'const pt = bim.store.addEntity("arch", {',
+    '  type: "IfcCartesianPoint",',
+    '  attributes: [[1.0, 2.0, 0.0]],',
+    '});',
+    'console.log("Allocated", pt.expressId);',
+    '',
+    '// Drop an entity entirely',
+    'bim.store.removeEntity(unwantedRef);',
+    '```',
+  ].join('\n');
+}
+
 function buildCreateContractCheatSheet(): string {
   const createNamespace = NAMESPACE_SCHEMAS.find((schema) => schema.name === 'create');
   if (!createNamespace) return '## BIM.CREATE CONTRACT CHEAT SHEET';
@@ -280,6 +343,7 @@ export function buildSystemPrompt(
   const intent = inferPromptIntent(task);
   const intentSection = buildIntentMethodSection(intent);
   const createContractCheatSheet = buildCreateContractCheatSheet();
+  const storeCheatSheet = buildStoreCheatSheet();
   const placementSemantics = buildPlacementSemanticsSection();
   const inspectionGuidance = buildInspectionGuidance();
 
@@ -326,9 +390,11 @@ ${intentSection}
 4. Keep scripts concise — avoid unnecessary abstractions
 5. Coordinates are in meters. Z is up. Do NOT assume every create method is storey-relative — use the method-specific placement rules below.
 6. For create or explicit rewrite turns, wrap runnable code in a \`\`\`js\`\`\` fence. For repair turns, return exactly one \`\`\`ifc-script-edits\`\`\` fence containing SEARCH/REPLACE blocks and no \`\`\`js\`\`\` fence.
-7. If the user asks to modify existing data, use \`bim.mutate\` or \`bim.query\` — NOT \`bim.create\`
+7. If the user asks to modify existing data, use \`bim.mutate\`, \`bim.store\`, or \`bim.query\` — NOT \`bim.create\`
    - Use \`bim.mutate.setAttribute(entity, "Description", "...")\` for root IFC attributes like \`Name\`, \`Description\`, \`ObjectType\`, or \`Tag\`
    - Use \`bim.mutate.setProperty(entity, "Pset_Name", "PropName", value)\` only for IfcPropertySet or quantity data
+   - Use \`bim.store.setPositionalAttribute(entity, index, value)\` for positional STEP-argument edits (profile dimensions, \`IfcCartesianPoint.Coordinates\`, and other index-addressed attributes — even when they have a symbolic name) — see BIM.STORE CHEAT SHEET
+   - Use \`bim.store.addEntity\` / \`bim.store.removeEntity\` to inject or drop raw STEP entities in an already-loaded model. Do NOT use \`bim.create\` for these — \`bim.create\` builds a fresh project
    - Distinguish occurrence vs type edits: occurrence/entity-specific changes belong on the occurrence; shared defaults and inherited type properties belong on the related \`Ifc...Type\` entity
    - If CURRENT MODEL STATE marks a selection as \`kind=type\`, treat it as a type object and avoid describing it as one physical placed occurrence
    - When an occurrence is selected, inspect \`bim.query.typeProperties(entity)\` before editing inherited values; mutate the type entity when the intent is to change all occurrences that share that type
@@ -353,6 +419,8 @@ ${intentSection}
 
 ${createContractCheatSheet}
 
+${storeCheatSheet}
+
 ${placementSemantics}
 - \`addIfcDoor\` and \`addIfcWindow\` do not infer host-wall orientation. If you place them next to angled walls, they will stay world-aligned unless you build the wall void another way.
 - For storey-relative methods, \`Z=0\` usually means floor level of that storey.
@@ -393,6 +461,39 @@ for (let i = 0; i < storeyCount; i++) {
 - If repeated elements appear only at one level, you probably reused one storey reference instead of iterating over the intended storeys.
 - If repeated world-placement elements stack at the base level, first check whether their Z coordinates include the current storey elevation.
 
+## SCHEDULING / 4D (IfcTask, IfcWorkSchedule, IfcRelSequence)
+- ifc-lite ships a Gantt panel in the lower workspace that plays a construction-sequence animation driven by IfcTask dates and the products each task controls.
+- Creating a schedule from scratch:
+  \`\`\`js
+  const h = bim.create.project({ Name: "Demo" });
+  const storey = bim.create.addIfcBuildingStorey(h, { Name: "Ground", Elevation: 0 });
+  const wallA = bim.create.addIfcWall(h, storey, { Start: [0,0,0], End: [5,0,0], Thickness: 0.2, Height: 3 });
+
+  const schedule = bim.create.addIfcWorkSchedule(h, {
+    Name: "Construction schedule",
+    StartTime: "2024-05-01T08:00:00",
+    FinishTime: "2024-06-30T17:00:00",
+    PredefinedType: "PLANNED",
+  });
+  const task = bim.create.addIfcTask(h, {
+    Name: "Install wall A",
+    PredefinedType: "INSTALLATION",
+    ScheduleStart: "2024-05-06T08:00:00",
+    ScheduleFinish: "2024-05-10T17:00:00",
+    ScheduleDuration: "P5D",
+  });
+  bim.create.assignTasksToWorkSchedule(h, schedule, [task]);
+  bim.create.assignProductsToTask(h, task, [wallA]);   // products reveal in the 4D animation
+  // bim.create.addIfcRelSequence(h, prevTask, task, { SequenceType: "FINISH_START", TimeLag: "P2D" });
+  // bim.create.nestTasks(h, summaryTask, [task]);    // WBS hierarchy
+  \`\`\`
+- Dates are ISO 8601 (\`2024-05-01T08:00:00\`). Durations are ISO 8601 (\`P5D\`, \`PT8H\`).
+- IfcTask.PredefinedType is an enum — prefer CONSTRUCTION, INSTALLATION, DEMOLITION, RENOVATION over free strings.
+- For milestones (e.g. "handover"), set \`IsMilestone: true\` and omit or equate start/finish.
+- \`assignProductsToTask\` is the bridge that lets the 4D Gantt animation reveal/hide elements as time advances. Always bind tasks to the elements they construct when the user wants the viewport to animate.
+- Reading an existing schedule: \`bim.schedule.data()\` returns { workSchedules, tasks, sequences }. Use it to inspect or validate a construction plan.
+- **CSV / Excel / PDF → schedule workflow:** when the user attaches a spreadsheet or PDF with activities and dates, parse it with \`bim.files.csv(name)\` (for CSV) or \`bim.files.text(name)\` (for text-extracted PDF/Excel content converted upstream). Map each row to an \`addIfcTask(...)\` call and resolve the \`products\` column — an IFC type like \`IfcWall\` expands to every matching entity, a globalId maps to one specific entity — into \`expressId\`s to feed \`assignProductsToTask\`. The \`Construction schedule (4D)\` script template is a ready-made starting point.
+
 ## API REFERENCE
 ${apiRef}
 

package/src/lib/llm/types.ts

@@ -124,9 +124,23 @@ export interface FileAttachment {
   imageBase64?: string;
   /** Whether this is an image attachment */
   isImage?: boolean;
+  /** Base64-encoded PDF data (for PDF attachments — Anthropic native document blocks) */
+  pdfBase64?: string;
+  /** Whether this is a PDF attachment */
+  isPdf?: boolean;
+  /** Whether this is a binary spreadsheet (xlsx/xls/ods) that we can't parse here yet. */
+  isSpreadsheetBinary?: 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 +150,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 +159,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

@@ -24,8 +24,21 @@ export interface RecentFileEntry {
   name: string;
   size: number;
   timestamp: number;
+  /** Native filesystem path (Tauri only) — enables direct re-open from disk. */
+  path?: string;
+  /** Last-modified epoch in ms when known (Tauri stat). */
+  modifiedMs?: number | null;
 }
 
+// Input shape for `recordRecentFiles` — accepts the optional native fields
+// so callers can persist a path / modifiedMs without lying about the type.
+export type RecentFileInput = {
+  name: string;
+  size: number;
+  path?: string;
+  modifiedMs?: number | null;
+};
+
 // ── localStorage (metadata) ─────────────────────────────────────────────
 
 export function getRecentFiles(): RecentFileEntry[] {
@@ -33,17 +46,30 @@ export function getRecentFiles(): RecentFileEntry[] {
   catch { return []; }
 }
 
-export function recordRecentFiles(files: { name: string; size: number }[]) {
+// Path-aware dedup key: when a native filesystem path is available it
+// uniquely identifies the file (so `A/model.ifc` and `B/model.ifc` are
+// kept separate); otherwise fall back to the name (browser uploads
+// don't expose paths).
+function recentKey(f: { name: string; path?: string }): string {
+  return f.path ? `path:${f.path}` : `name:${f.name}`;
+}
+
+export function recordRecentFiles(files: RecentFileInput[]) {
   try {
-    const names = new Set(files.map(f => f.name));
-    const existing = getRecentFiles().filter(f => !names.has(f.name));
+    const incomingKeys = new Set(files.map(recentKey));
+    const existing = getRecentFiles().filter(f => !incomingKeys.has(recentKey(f)));
     const entries: RecentFileEntry[] = files.map(f => ({
       name: f.name,
       size: f.size,
       timestamp: Date.now(),
+      path: f.path,
+      modifiedMs: f.modifiedMs ?? null,
     }));
     localStorage.setItem(KEY, JSON.stringify([...entries, ...existing].slice(0, 10)));
-  } catch { /* noop */ }
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.warn('[recent-files] failed to persist recent files metadata', err);
+  }
 }
 
 /** Format bytes into human-readable size */
@@ -104,6 +130,14 @@ export async function cacheFileBlobs(files: File[]): Promise<void> {
 
 /** Retrieve a cached file blob and reconstruct a File object. */
 export async function getCachedFile(target: string | RecentFileEntry): Promise<File | null> {
+  // Path-bearing entries (Tauri filesystem) are uniquely keyed by path
+  // in the recents list, but the IndexedDB cache is name-keyed. A
+  // name-only hit could resolve `A/model.ifc` to the cached blob from
+  // `B/model.ifc`, opening the wrong file silently. Defer to the
+  // caller's native re-open path instead.
+  if (typeof target !== 'string' && target.path) {
+    return null;
+  }
   const name = typeof target === 'string' ? target : target.name;
   try {
     const db = await openDB();