@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/lib/llm/models.ts

@@ -4,11 +4,10 @@
 
 /**
  * LLM model registry.
- * Model IDs are sourced from environment variables only.
- * Pro model cost metadata comes from cost-bucket env vars:
- * - *_PRO_MODELS_LOW => $
- * - *_PRO_MODELS_MEDIUM => $$
- * - *_PRO_MODELS_HIGH => $$$
+ *
+ * Free models: sourced from VITE_LLM_FREE_MODELS env var, served through the server proxy.
+ * BYOK models: statically defined Anthropic and OpenAI models, accessed directly from the
+ * browser using the user's own API key.
  */
 
 import type { LLMModel } from './types.js';
@@ -93,46 +92,25 @@ function humanizeModelSlug(slug: string): string {
     .join(' ');
 }
 
-function buildModel(id: string, tier: 'free' | 'pro', cost?: LLMModel['cost']): LLMModel {
+function buildModel(id: string, tier: 'free' | 'byok', cost?: LLMModel['cost'], source?: LLMModel['source']): LLMModel {
   const [providerRaw, modelRaw = id] = id.split('/');
   return {
     id,
     tier,
+    source: source ?? 'proxy',
     name: humanizeModelSlug(modelRaw),
     provider: titleCaseProvider(providerRaw ?? 'Unknown'),
     contextWindow: 128_000,
     supportsImages: false,
     supportsFileAttachments: true,
-    cost: tier === 'pro' ? cost : undefined,
+    cost: tier === 'byok' ? cost : undefined,
   };
 }
 
 const freeModelIds = uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_FREE_MODELS', 'LLM_FREE_MODELS']));
-const proLowCostIds = uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_PRO_MODELS_LOW', 'LLM_PRO_MODELS_LOW']));
-const proMediumCostIds = uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_PRO_MODELS_MEDIUM', 'LLM_PRO_MODELS_MEDIUM']));
-const proHighCostIds = uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_PRO_MODELS_HIGH', 'LLM_PRO_MODELS_HIGH']));
-
-// Backward-compatible fallback for older env shape with one pro list.
-const legacyProIds = uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_PRO_MODELS', 'LLM_PRO_MODELS']));
-const useLegacyProList = proLowCostIds.length === 0 && proMediumCostIds.length === 0 && proHighCostIds.length === 0;
 
 const rawFreeModels: LLMModel[] = freeModelIds.map((id) => buildModel(id, 'free'));
 
-const proCostBuckets: Array<{ ids: string[]; cost: LLMModel['cost'] }> = [
-  { ids: proLowCostIds, cost: '$' },
-  { ids: useLegacyProList ? legacyProIds : proMediumCostIds, cost: '$$' },
-  { ids: proHighCostIds, cost: '$$$' },
-];
-
-const seenProModelIds = new Set<string>();
-const rawProModels: LLMModel[] = proCostBuckets.flatMap(({ ids, cost }) =>
-  ids.flatMap((id) => {
-    if (seenProModelIds.has(id)) return [];
-    seenProModelIds.add(id);
-    return [buildModel(id, 'pro', cost)];
-  }),
-);
-
 const imageCapableModelIds = new Set(
   uniqueInOrder(parseCsvFromFirstDefined(['VITE_LLM_IMAGE_MODELS', 'LLM_IMAGE_MODELS'])),
 );
@@ -155,43 +133,127 @@ function applyCapabilities(model: LLMModel): LLMModel {
 }
 
 export const FREE_MODELS: LLMModel[] = rawFreeModels.map(applyCapabilities);
-export const PRO_MODELS: LLMModel[] = rawProModels.map(applyCapabilities);
-export const ALL_MODELS = [...FREE_MODELS, ...PRO_MODELS];
+
+// ── BYOK (Bring Your Own Key) models ───────────────────────────────────────
+// Static list of well-known models users can access with their own API keys.
+// Requests go directly from the browser to the provider (no server proxy).
+
+const ANTHROPIC_BYOK_MODELS: LLMModel[] = [
+  {
+    id: 'claude-opus-4-6',
+    name: 'Claude Opus 4.6',
+    provider: 'Anthropic',
+    tier: 'byok',
+    source: 'anthropic',
+    contextWindow: 200_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$$$',
+  },
+  {
+    id: 'claude-sonnet-4-6',
+    name: 'Claude Sonnet 4.6',
+    provider: 'Anthropic',
+    tier: 'byok',
+    source: 'anthropic',
+    contextWindow: 200_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$$',
+  },
+  {
+    id: 'claude-haiku-4-5-20251001',
+    name: 'Claude Haiku 4.5',
+    provider: 'Anthropic',
+    tier: 'byok',
+    source: 'anthropic',
+    contextWindow: 200_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$',
+  },
+];
+
+const OPENAI_BYOK_MODELS: LLMModel[] = [
+  {
+    id: 'gpt-5.4',
+    name: 'GPT-5.4',
+    provider: 'OpenAI',
+    tier: 'byok',
+    source: 'openai',
+    contextWindow: 128_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$$$',
+  },
+  {
+    id: 'gpt-5.3-codex',
+    name: 'GPT-5.3 Codex',
+    provider: 'OpenAI',
+    tier: 'byok',
+    source: 'openai',
+    contextWindow: 128_000,
+    supportsImages: false,
+    supportsFileAttachments: true,
+    cost: '$$',
+    openaiApi: 'responses',
+  },
+  {
+    id: 'gpt-5.4-mini-2026-03-17',
+    name: 'GPT-5.4 Mini',
+    provider: 'OpenAI',
+    tier: 'byok',
+    source: 'openai',
+    contextWindow: 128_000,
+    supportsImages: true,
+    supportsFileAttachments: true,
+    cost: '$',
+  },
+];
+
+export const BYOK_MODELS: LLMModel[] = [...ANTHROPIC_BYOK_MODELS, ...OPENAI_BYOK_MODELS];
+export const ALL_MODELS = [...FREE_MODELS, ...BYOK_MODELS];
 
 const FALLBACK_MODEL: LLMModel = {
   id: 'llm-model-missing',
   name: 'No model configured',
   provider: 'Unknown',
   tier: 'free',
+  source: 'proxy',
   contextWindow: 128_000,
   supportsImages: false,
   supportsFileAttachments: true,
-  notes: 'Set VITE_LLM_FREE_MODELS and VITE_LLM_PRO_MODELS_LOW/MEDIUM/HIGH in environment.',
+  notes: 'Set VITE_LLM_FREE_MODELS in environment or add your own API key in Settings.',
 };
 
-export const DEFAULT_FREE_MODEL = FREE_MODELS[0] ?? PRO_MODELS[0] ?? FALLBACK_MODEL;
-export const DEFAULT_PRO_MODEL = PRO_MODELS[0] ?? DEFAULT_FREE_MODEL;
+export const DEFAULT_FREE_MODEL = FREE_MODELS[0] ?? FALLBACK_MODEL;
+export const DEFAULT_BYOK_MODEL = BYOK_MODELS[0] ?? DEFAULT_FREE_MODEL;
 
 export function getModelById(id: string): LLMModel | undefined {
   return ALL_MODELS.find((m) => m.id === id);
 }
 
-/** Check whether a model ID requires a pro subscription */
-export function requiresPro(modelId: string): boolean {
+/** Check whether a model ID requires a user-provided API key (BYOK) */
+export function requiresByokKey(modelId: string): boolean {
   const model = getModelById(modelId);
-  return model?.tier === 'pro';
+  return model?.tier === 'byok';
+}
+
+/** Get BYOK models available for a given provider source */
+export function getByokModelsForSource(source: 'anthropic' | 'openai'): LLMModel[] {
+  return BYOK_MODELS.filter((m) => m.source === source);
 }
 
-export function getDefaultModelForEntitlement(hasPro: boolean): LLMModel {
-  return hasPro ? DEFAULT_PRO_MODEL : DEFAULT_FREE_MODEL;
+export function getDefaultModelForEntitlement(hasByokKey: boolean): LLMModel {
+  return hasByokKey ? DEFAULT_BYOK_MODEL : DEFAULT_FREE_MODEL;
 }
 
-export function coerceModelForEntitlement(modelId: string | null | undefined, hasPro: boolean): string {
+export function coerceModelForEntitlement(modelId: string | null | undefined, hasByokKey: boolean): string {
   if (modelId) {
     const model = getModelById(modelId);
-    if (model && (!requiresPro(modelId) || hasPro)) {
+    if (model && (!requiresByokKey(modelId) || hasByokKey)) {
       return modelId;
     }
   }
-  return getDefaultModelForEntitlement(hasPro).id;
+  return getDefaultModelForEntitlement(hasByokKey).id;
 }

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

@@ -53,8 +53,6 @@ export interface StreamOptions {
   messages: StreamMessage[];
   /** System prompt */
   system?: string;
-  /** Auth JWT */
-  authToken?: string | null;
   /** AbortSignal for cancellation */
   signal?: AbortSignal;
   /** Called for each text chunk as it arrives */
@@ -117,16 +115,59 @@ export function drainSseBuffer(buffer: string, flush: boolean = false): { events
   };
 }
 
+/**
+ * Read an SSE stream, invoking onEvent for each `data:` payload.
+ * Skips `[DONE]` sentinels and malformed lines. Returns true if the stream
+ * completed normally; false on abort or error (errors are forwarded via
+ * onError, aborts are silent).
+ */
+export async function readSseStream(
+  body: ReadableStream<Uint8Array>,
+  signal: AbortSignal | undefined,
+  onEvent: (data: string) => void,
+  onError: (err: Error) => void,
+): Promise<boolean> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  const dispatchDrained = (events: string[]) => {
+    for (const evt of events) {
+      for (const line of evt.split('\n')) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6);
+        if (data === '[DONE]') continue;
+        try { onEvent(data); } catch { /* skip malformed */ }
+      }
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const drained = drainSseBuffer(buffer);
+      buffer = drained.remainder;
+      dispatchDrained(drained.events);
+    }
+    buffer += decoder.decode();
+    dispatchDrained(drainSseBuffer(buffer, true).events);
+    return true;
+  } catch (err) {
+    if (signal?.aborted) return false;
+    onError(err instanceof Error ? err : new Error(String(err)));
+    return false;
+  }
+}
+
 /**
  * Fetch current usage snapshot without sending a chat message.
  * Used for instant UI hydration and periodic refresh.
  */
-export async function fetchUsageSnapshot(proxyUrl: string, authToken?: string | null): Promise<UsageInfo | null> {
+export async function fetchUsageSnapshot(proxyUrl: string): Promise<UsageInfo | null> {
   const isDev = Boolean((import.meta as unknown as { env?: Record<string, unknown> }).env?.DEV);
   const headers: Record<string, string> = {};
-  if (authToken) {
-    headers['Authorization'] = `Bearer ${authToken}`;
-  }
 
   const snapshotUrl = `${proxyUrl}${proxyUrl.includes('?') ? '&' : '?'}usage=1`;
   const appSnapshotUrl = '/api/chat?usage=1';
@@ -165,15 +206,12 @@ export async function fetchUsageSnapshot(proxyUrl: string, authToken?: string |
  * Parses SSE format (data: {...}\n\n).
  */
 export async function streamChat(options: StreamOptions): Promise<void> {
-  const { proxyUrl, model, messages, system, authToken, signal, onChunk, onComplete, onError, onUsageInfo, onFinishReason } = options;
+  const { proxyUrl, model, messages, system, signal, onChunk, onComplete, onError, onUsageInfo, onFinishReason } = options;
   const isDev = Boolean((import.meta as unknown as { env?: Record<string, unknown> }).env?.DEV);
 
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
   };
-  if (authToken) {
-    headers['Authorization'] = `Bearer ${authToken}`;
-  }
 
   const requestBody = JSON.stringify({ messages, model, system });
   const fetchChat = async (url: string) => {
@@ -255,21 +293,13 @@ export async function streamChat(options: StreamOptions): Promise<void> {
       };
       errorDetail = errorBody.error || errorDetail;
 
-      if (response.status === 403 && errorBody.upgrade) {
-        errorDetail = 'Upgrade to Pro to use this model.';
-      }
-
       if (response.status === 401) {
-        errorDetail = 'Authentication expired. Please sign out and sign in again.';
+        errorDetail = 'Authentication error.';
       }
 
       if (response.status === 429) {
-        if (errorBody.type === 'credits') {
-          const contactEmail = errorBody.contactEmail as string | undefined;
-          const contactSuffix = contactEmail ? ` Need more? Reach out at ${contactEmail}.` : '';
-          errorDetail = `Monthly credits used up. Resets ${errorBody.resetAt ? new Date(errorBody.resetAt).toLocaleDateString() : 'next month'}.${contactSuffix}`;
-        } else if (errorBody.type === 'request_cap') {
-          errorDetail = errorBody.error || 'Daily limit reached. Upgrade to Pro for more.';
+        if (errorBody.type === 'request_cap') {
+          errorDetail = errorBody.error || 'Daily limit reached. Add your own API key in Settings for unlimited access.';
         } else {
           errorDetail = errorBody.error || 'Limit reached. Please try again later.';
         }
@@ -308,102 +338,36 @@ export async function streamChat(options: StreamOptions): Promise<void> {
     return;
   }
 
-  // Parse SSE stream
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
   let fullText = '';
   let finishReason: string | null = null;
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-
-      const drained = drainSseBuffer(buffer);
-      buffer = drained.remainder;
+  const ok = await readSseStream(response.body, signal, (data) => {
+    const parsed = JSON.parse(data) as {
+      __ifcLiteUsage?: UsageInfo;
+      choices?: Array<{
+        delta?: { content?: string };
+        finish_reason?: string | null;
+      }>;
+    };
 
-      for (const event of drained.events) {
-        for (const line of event.split('\n')) {
-          if (!line.startsWith('data: ')) continue;
-          const data = line.slice(6);
-
-          if (data === '[DONE]') continue;
-
-          try {
-            const parsed = JSON.parse(data) as {
-              __ifcLiteUsage?: UsageInfo;
-              choices?: Array<{
-                delta?: { content?: string };
-                finish_reason?: string | null;
-              }>;
-            };
-
-            // Final usage update emitted by proxy after stream-end reconciliation.
-            if (parsed.__ifcLiteUsage && onUsageInfo) {
-              onUsageInfo(parsed.__ifcLiteUsage);
-              continue;
-            }
-
-            const content = parsed.choices?.[0]?.delta?.content;
-            if (content) {
-              fullText += content;
-              onChunk(content);
-            }
-            const chunkFinishReason = parsed.choices?.[0]?.finish_reason;
-            if (chunkFinishReason) {
-              finishReason = chunkFinishReason;
-            }
-          } catch {
-            // Skip malformed SSE lines
-          }
-        }
-      }
+    // Final usage update emitted by proxy after stream-end reconciliation.
+    if (parsed.__ifcLiteUsage && onUsageInfo) {
+      onUsageInfo(parsed.__ifcLiteUsage);
+      return;
     }
-    buffer += decoder.decode();
-    const drained = drainSseBuffer(buffer, true);
-    for (const event of drained.events) {
-      for (const line of event.split('\n')) {
-        if (!line.startsWith('data: ')) continue;
-        const data = line.slice(6);
 
-        if (data === '[DONE]') continue;
-
-        try {
-          const parsed = JSON.parse(data) as {
-            __ifcLiteUsage?: UsageInfo;
-            choices?: Array<{
-              delta?: { content?: string };
-              finish_reason?: string | null;
-            }>;
-          };
-
-          if (parsed.__ifcLiteUsage && onUsageInfo) {
-            onUsageInfo(parsed.__ifcLiteUsage);
-            continue;
-          }
-
-          const content = parsed.choices?.[0]?.delta?.content;
-          if (content) {
-            fullText += content;
-            onChunk(content);
-          }
-          const chunkFinishReason = parsed.choices?.[0]?.finish_reason;
-          if (chunkFinishReason) {
-            finishReason = chunkFinishReason;
-          }
-        } catch {
-          // Skip malformed SSE lines
-        }
-      }
+    const content = parsed.choices?.[0]?.delta?.content;
+    if (content) {
+      fullText += content;
+      onChunk(content);
     }
-  } catch (err) {
-    if (signal?.aborted) return;
-    onError(err instanceof Error ? err : new Error(String(err)));
-    return;
-  }
+    const chunkFinishReason = parsed.choices?.[0]?.finish_reason;
+    if (chunkFinishReason) {
+      finishReason = chunkFinishReason;
+    }
+  }, onError);
+
+  if (!ok) return;
 
   onFinishReason?.(finishReason);
   onComplete(fullText);

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

@@ -0,0 +1,130 @@
+/* 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 { streamOpenAiChat } from './stream-direct.js';
+
+const CODEX_MODEL_ID = 'gpt-5.3-codex';
+
+type FetchImpl = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+function withMockFetch<T>(impl: FetchImpl, fn: () => Promise<T>): Promise<T> {
+  const original = globalThis.fetch;
+  globalThis.fetch = impl as typeof globalThis.fetch;
+  return fn().finally(() => {
+    globalThis.fetch = original;
+  });
+}
+
+function sseResponse(events: string[]): Response {
+  return new Response(new ReadableStream({
+    start(controller) {
+      for (const evt of events) {
+        controller.enqueue(new TextEncoder().encode(`data: ${evt}\n\n`));
+      }
+      controller.close();
+    },
+  }), {
+    status: 200,
+    headers: { 'Content-Type': 'text/event-stream' },
+  });
+}
+
+test('streamOpenAiChat (Responses API) reports finish_reason=length when output is truncated', async () => {
+  await withMockFetch(
+    async () => sseResponse([
+      JSON.stringify({ type: 'response.output_text.delta', delta: 'partial' }),
+      JSON.stringify({
+        type: 'response.incomplete',
+        response: { status: 'incomplete', incomplete_details: { reason: 'max_output_tokens' } },
+      }),
+    ]),
+    async () => {
+      let fullText = '';
+      let finishReason: string | null = null;
+      await streamOpenAiChat('sk-test', {
+        model: CODEX_MODEL_ID,
+        messages: [{ role: 'user', content: 'hi' }],
+        onChunk: (text) => { fullText += text; },
+        onComplete: (text) => { fullText = text; },
+        onFinishReason: (reason) => { finishReason = reason; },
+        onError: (err) => { throw err; },
+      });
+      assert.equal(fullText, 'partial');
+      assert.equal(finishReason, 'length');
+    },
+  );
+});
+
+test('streamOpenAiChat (Responses API) reports finish_reason=length when incomplete has no reason', async () => {
+  await withMockFetch(
+    async () => sseResponse([
+      JSON.stringify({ type: 'response.output_text.delta', delta: 'partial' }),
+      JSON.stringify({
+        type: 'response.incomplete',
+        response: { status: 'incomplete' },
+      }),
+    ]),
+    async () => {
+      let finishReason: string | null = null;
+      await streamOpenAiChat('sk-test', {
+        model: CODEX_MODEL_ID,
+        messages: [{ role: 'user', content: 'hi' }],
+        onChunk: () => undefined,
+        onComplete: () => undefined,
+        onFinishReason: (reason) => { finishReason = reason; },
+        onError: (err) => { throw err; },
+      });
+      assert.equal(finishReason, 'length');
+    },
+  );
+});
+
+test('streamOpenAiChat (Responses API) reports finish_reason=stop on normal completion', async () => {
+  await withMockFetch(
+    async () => sseResponse([
+      JSON.stringify({ type: 'response.output_text.delta', delta: 'ok' }),
+      JSON.stringify({
+        type: 'response.completed',
+        response: { status: 'completed' },
+      }),
+    ]),
+    async () => {
+      let finishReason: string | null = null;
+      await streamOpenAiChat('sk-test', {
+        model: CODEX_MODEL_ID,
+        messages: [{ role: 'user', content: 'hi' }],
+        onChunk: () => undefined,
+        onComplete: () => undefined,
+        onFinishReason: (reason) => { finishReason = reason; },
+        onError: (err) => { throw err; },
+      });
+      assert.equal(finishReason, 'stop');
+    },
+  );
+});
+
+test('streamOpenAiChat (Responses API) hits the /v1/responses endpoint for codex models', async () => {
+  let capturedUrl: string | null = null;
+  await withMockFetch(
+    async (input) => {
+      capturedUrl = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+      return sseResponse([
+        JSON.stringify({ type: 'response.output_text.delta', delta: 'x' }),
+        JSON.stringify({ type: 'response.completed', response: { status: 'completed' } }),
+      ]);
+    },
+    async () => {
+      await streamOpenAiChat('sk-test', {
+        model: CODEX_MODEL_ID,
+        messages: [{ role: 'user', content: 'hi' }],
+        onChunk: () => undefined,
+        onComplete: () => undefined,
+        onError: (err) => { throw err; },
+      });
+    },
+  );
+  assert.equal(capturedUrl, 'https://api.openai.com/v1/responses');
+});