@ifc-lite/viewer 1.14.2 → 1.14.4

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

@@ -0,0 +1,410 @@
+/* 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/. */
+
+/**
+ * Streaming client for the LLM chat proxy.
+ *
+ * Sends chat messages to the Edge proxy and streams the response
+ * back as SSE. Extracts usage headers from the response for UI display.
+ */
+
+/** A text content part in a multimodal message */
+export interface TextContentPart {
+  type: 'text';
+  text: string;
+}
+
+/** An image content part in a multimodal message */
+export interface ImageContentPart {
+  type: 'image_url';
+  image_url: { url: string };
+}
+
+export type MessageContent = string | Array<TextContentPart | ImageContentPart>;
+
+export interface StreamMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: MessageContent;
+}
+
+/** Usage info extracted from proxy response headers */
+export interface UsageInfo {
+  /** 'credits' for pro, 'requests' for free */
+  type: 'credits' | 'requests';
+  /** Amount used: credits consumed (pro) or request count (free) */
+  used: number;
+  /** Limit: credit allowance (pro) or request cap (free) */
+  limit: number;
+  /** Percentage used (0-100) */
+  pct: number;
+  /** Reset time (epoch seconds) */
+  resetAt: number;
+  /** Whether this request can consume credits (pro paid model) */
+  billable?: boolean;
+}
+
+export interface StreamOptions {
+  /** Proxy URL (Edge Function) */
+  proxyUrl: string;
+  /** Model ID */
+  model: string;
+  /** Conversation messages */
+  messages: StreamMessage[];
+  /** System prompt */
+  system?: string;
+  /** Auth JWT */
+  authToken?: string | null;
+  /** AbortSignal for cancellation */
+  signal?: AbortSignal;
+  /** Called for each text chunk as it arrives */
+  onChunk: (text: string) => void;
+  /** Called when the stream completes */
+  onComplete: (fullText: string) => void;
+  /** Called with the model/provider finish reason when available */
+  onFinishReason?: (finishReason: string | null) => void;
+  /** Called on error */
+  onError: (error: Error) => void;
+  /** Called with usage info from response headers */
+  onUsageInfo?: (usage: UsageInfo) => void;
+}
+
+const STREAM_REQUEST_TIMEOUT_MS = 45_000;
+
+function parseUsageFromHeaders(headers: Headers): UsageInfo | null {
+  const creditsUsed = parseInt(headers.get('X-Credits-Used') ?? '0', 10);
+  const creditsLimit = parseInt(headers.get('X-Credits-Limit') ?? '0', 10);
+  const usageUsed = parseInt(headers.get('X-Usage-Used') ?? '0', 10);
+  const usageLimit = parseInt(headers.get('X-Usage-Limit') ?? '0', 10);
+
+  if (creditsLimit > 0) {
+    const billable = headers.get('X-Credits-Billable');
+    return {
+      type: 'credits',
+      used: creditsUsed,
+      limit: creditsLimit,
+      pct: parseInt(headers.get('X-Credits-Pct') ?? '0', 10),
+      resetAt: parseInt(headers.get('X-Credits-Reset') ?? '0', 10),
+      billable: billable === null ? undefined : billable === 'true',
+    };
+  }
+
+  if (usageLimit > 0) {
+    return {
+      type: 'requests',
+      used: usageUsed,
+      limit: usageLimit,
+      pct: parseInt(headers.get('X-Usage-Pct') ?? '0', 10),
+      resetAt: parseInt(headers.get('X-Usage-Reset') ?? '0', 10),
+    };
+  }
+
+  return null;
+}
+
+export function drainSseBuffer(buffer: string, flush: boolean = false): { events: string[]; remainder: string } {
+  if (flush) {
+    const trimmed = buffer.trim();
+    return {
+      events: trimmed ? trimmed.split('\n\n').filter(Boolean) : [],
+      remainder: '',
+    };
+  }
+  const parts = buffer.split('\n\n');
+  return {
+    events: parts.slice(0, -1).filter(Boolean),
+    remainder: parts.at(-1) ?? '',
+  };
+}
+
+/**
+ * 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> {
+  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';
+  const canFallbackToAppProxy = isDev && snapshotUrl !== appSnapshotUrl;
+  const fetchSnapshot = (url: string) => fetch(url, { method: 'GET', headers });
+
+  let response: Response;
+  try {
+    response = await fetchSnapshot(snapshotUrl);
+  } catch {
+    if (!canFallbackToAppProxy) return null;
+    try {
+      response = await fetchSnapshot(appSnapshotUrl);
+    } catch {
+      return null;
+    }
+  }
+
+  if (!response.ok && response.status === 404 && canFallbackToAppProxy) {
+    try {
+      const retry = await fetchSnapshot(appSnapshotUrl);
+      if (retry.ok || retry.status !== 404) {
+        response = retry;
+      }
+    } catch {
+      // keep original response
+    }
+  }
+
+  if (!response.ok) return null;
+  return parseUsageFromHeaders(response.headers);
+}
+
+/**
+ * Stream a chat completion from the LLM proxy.
+ * 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 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) => {
+    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);
+        controller.abort(signal.reason);
+      } else {
+        signal.addEventListener('abort', abortFromParent, { once: true });
+      }
+    }
+    try {
+      return await fetch(url, {
+        method: 'POST',
+        headers,
+        body: requestBody,
+        signal: controller.signal,
+      });
+    } catch (error) {
+      if (controller.signal.aborted && !signal?.aborted && controller.signal.reason instanceof Error) {
+        throw controller.signal.reason;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener('abort', abortFromParent);
+    }
+  };
+  const canFallbackToAppProxy = isDev && proxyUrl !== '/api/chat';
+
+  let response: Response;
+  try {
+    response = await fetchChat(proxyUrl);
+  } catch (err) {
+    if (signal?.aborted) return;
+    if (!canFallbackToAppProxy) {
+      onError(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    // Local dev resilience: if direct API URL is down/unreachable, retry once
+    // through app-relative proxy path.
+    try {
+      response = await fetchChat('/api/chat');
+    } catch (fallbackErr) {
+      if (signal?.aborted) return;
+      onError(fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr)));
+      return;
+    }
+  }
+
+  // Local dev resilience: if direct API URL 404s (common when vercel dev
+  // port/process changes), retry once through the app proxy path.
+  if (!response.ok && response.status === 404 && canFallbackToAppProxy) {
+    try {
+      const retry = await fetchChat('/api/chat');
+      if (retry.ok || retry.status !== 404) {
+        response = retry;
+      }
+    } catch {
+      // ignore fallback failure, original response handling below will surface error
+    }
+  }
+
+  if (!response.ok) {
+    let errorDetail = `HTTP ${response.status}`;
+    try {
+      const errorBody = await response.json() as {
+        error?: string;
+        code?: string;
+        providerMessage?: string;
+        model?: string;
+        type?: string;
+        upgrade?: boolean;
+        contactEmail?: string;
+        resetAt?: number;
+      };
+      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.';
+      }
+
+      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.';
+        } else {
+          errorDetail = errorBody.error || 'Limit reached. Please try again later.';
+        }
+      }
+
+      if (response.status === 502 && errorBody.code === 'provider_model_not_found') {
+        const providerMessage = errorBody.providerMessage?.trim();
+        const modelLabel = errorBody.model ? ` ${errorBody.model}` : '';
+        if (providerMessage) {
+          errorDetail = `Provider routing unavailable for${modelLabel}. ${providerMessage}`;
+        } else {
+          errorDetail = `Provider routing unavailable for${modelLabel}. Try again shortly or switch model.`;
+        }
+      }
+
+      if (errorBody.code === 'provider_error' && errorBody.providerMessage) {
+        errorDetail = `${errorBody.error ?? `Request failed (${response.status})`}\nProvider: ${errorBody.providerMessage}`;
+      }
+    } catch {
+      // ignore parse failure
+    }
+    onError(new Error(errorDetail));
+    return;
+  }
+
+  // Extract usage info from response headers
+  if (onUsageInfo) {
+    const usage = parseUsageFromHeaders(response.headers);
+    if (usage) {
+      onUsageInfo(usage);
+    }
+  }
+
+  if (!response.body) {
+    onError(new Error('No response body'));
+    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;
+
+      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
+          }
+        }
+      }
+    }
+    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
+        }
+      }
+    }
+  } catch (err) {
+    if (signal?.aborted) return;
+    onError(err instanceof Error ? err : new Error(String(err)));
+    return;
+  }
+
+  onFinishReason?.(finishReason);
+  onComplete(fullText);
+}

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

@@ -0,0 +1,181 @@
+/* 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 { NAMESPACE_SCHEMAS } from '@ifc-lite/sandbox/schema';
+import { buildSystemPrompt } from './system-prompt.js';
+import { createPatchDiagnostic } from './script-diagnostics.js';
+
+test('system prompt includes all schema namespaces and methods', () => {
+  const prompt = buildSystemPrompt();
+
+  for (const schema of NAMESPACE_SCHEMAS) {
+    assert.match(
+      prompt,
+      new RegExp(`###\\s+bim\\.${schema.name}\\s+—`),
+      `Missing namespace heading for bim.${schema.name}`,
+    );
+    for (const method of schema.methods) {
+      assert.match(
+        prompt,
+        new RegExp(`bim\\.${schema.name}\\.${method.name}\\(`),
+        `Missing method reference for bim.${schema.name}.${method.name}()`,
+      );
+    }
+  }
+});
+
+test('system prompt includes script editor revision context when provided', () => {
+  const prompt = buildSystemPrompt(undefined, undefined, {
+    content: 'const n = 1;',
+    revision: 42,
+    selection: { from: 6, to: 7 },
+  });
+  assert.match(prompt, /Current script revision:\s+42/);
+  assert.match(prompt, /Current selection:\s+from=6, to=7/);
+  assert.match(prompt, /```ifc-script-edits/);
+  assert.match(prompt, /<<<<<<< SEARCH/);
+  assert.match(prompt, /Copy every SEARCH block exactly from the CURRENT script/);
+  assert.match(prompt, /Each SEARCH block must match exactly one location/);
+  assert.match(prompt, /The system also understands legacy JSON edit ops, but SEARCH\/REPLACE is the default/);
+  assert.match(prompt, /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\./);
+  assert.match(prompt, /Do NOT answer with a detached snippet/);
+});
+
+test('system prompt includes storey hierarchy context when provided', () => {
+  const prompt = buildSystemPrompt({
+    models: [{ name: 'Tower', entityCount: 500 }],
+    typeCounts: { IfcWall: 120 },
+    selectedCount: 0,
+    storeys: [
+      { modelName: 'Tower', name: 'Level 01', elevation: 0, height: 3.5, elementCount: 42 },
+      { modelName: 'Tower', name: 'Level 02', elevation: 3.5, height: 3.5, elementCount: 40 },
+    ],
+  });
+  assert.match(prompt, /CURRENT MODEL STATE/);
+  assert.match(prompt, /Storeys: Tower: Level 01 @ 0m, height≈3.5m, elements=42 \| Tower: Level 02 @ 3.5m, height≈3.5m, elements=40/);
+});
+
+test('system prompt includes selected entity IFC context when provided', () => {
+  const prompt = buildSystemPrompt({
+    models: [{ name: 'Tower', entityCount: 500 }],
+    typeCounts: { IfcWall: 120 },
+    selectedCount: 2,
+    selectedEntities: [
+      {
+        modelName: 'Tower',
+        name: 'Facade Panel A',
+        type: 'IfcCurtainWall',
+        selectionKind: 'occurrence',
+        storeyName: 'Level 10',
+        storeyElevation: 31.5,
+        propertySets: ['Pset_CurtainWallCommon'],
+        typePropertySets: ['Pset_CurtainWallTypeCommon'],
+        quantitySets: ['Qto_CurtainWallBaseQuantities'],
+        materialName: 'Aluminium',
+        classifications: ['A-123'],
+      },
+      {
+        modelName: 'Tower',
+        name: 'Exterior Wall Type',
+        type: 'IfcWallType',
+        selectionKind: 'type',
+        propertySets: ['Pset_WallCommon'],
+        classifications: ['A-WALL'],
+      },
+    ],
+  });
+  assert.match(prompt, /2 entities currently selected in the viewer/);
+  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 method-specific create contract guidance', () => {
+  const prompt = buildSystemPrompt();
+  assert.match(prompt, /BIM\.CREATE CONTRACT CHEAT SHEET/);
+  assert.match(prompt, /addIfcRoof.*mono-pitch roof slab.*Do NOT use `Profile`, `Height`, or `ExtrusionHeight`/s);
+  assert.match(prompt, /addIfcGableRoof.*dual-pitch house roofs/s);
+  assert.match(prompt, /addIfcWallDoor.*wall-local `Position`/s);
+  assert.match(prompt, /addIfcWallWindow.*wall-local `Position`/s);
+  assert.match(prompt, /Wall-hosted openings: use `Openings` inside `addIfcWall/);
+  assert.match(prompt, /resolve the target storeys first and then add geometry to EACH intended storey/);
+  assert.match(prompt, /When CURRENT MODEL STATE includes storeys, use those storey names\/elevations as the source of truth/);
+  assert.match(prompt, /inspect the actual model first.*bim\.query\.selection\(\).*bim\.query\.storeys\(\).*bim\.query\.path\(entity\).*bim\.query\.materials\(entity\).*bim\.query\.classifications\(entity\)/s);
+  assert.match(prompt, /Materials are usually NOT ordinary property-set values/);
+  assert.match(prompt, /Prefer `bim\.query\.classifications\(entity\)` over guessing ad-hoc classification properties/);
+  assert.match(prompt, /const material = bim\.query\.materials\(wall\);/);
+  assert.match(prompt, /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/);
+  assert.match(prompt, /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/);
+  assert.match(prompt, /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/);
+  assert.match(prompt, /IFC export preserves edits to type-owned property sets when you export after applying mutations/);
+  assert.match(prompt, /addIfcDoor` and `addIfcWindow`: these create standalone world-aligned elements/);
+  assert.match(prompt, /If doors or windows appear rotated 90° relative to a wall/);
+  assert.match(prompt, /If repeated elements appear only at one level/);
+  assert.match(prompt, /house, pitched-roof, or gable-roof requests, prefer `addIfcGableRoof`/);
+  assert.match(prompt, /If the user asks for a house roof, pitched roof, or gable roof, default to `addIfcGableRoof`/);
+  assert.match(prompt, /convert it to radians first .*addIfcRoof.*addIfcGableRoof/s);
+  assert.match(prompt, /addElement.*Use `IfcType`, `Placement:/s);
+  assert.match(prompt, /Use `IfcType` not `Type`; use `Placement` not `Position`/);
+  assert.match(prompt, /Many advanced methods are world-placement based/);
+  assert.match(prompt, /addIfcPlate.*`Position`, `Width`, `Depth`, `Thickness`/);
+  assert.match(prompt, /Mixed multi-level scripts often combine both/);
+  assert.match(prompt, /those calls should usually use `elevation`.*`Start`.*`End`.*`Position`/s);
+  assert.match(prompt, /const elevation = i \* storeyHeight;/);
+  assert.match(prompt, /When a fix targets an existing script, preserve the project handle, storey handles, loop variables/);
+  assert.match(prompt, /If a previous repair was rejected for losing context, keep the full script intact/);
+  assert.match(prompt, /If repeated world-placement elements stack at the base level/);
+});
+
+test('system prompt adapts task focus for repair turns', () => {
+  const prompt = buildSystemPrompt(undefined, undefined, {
+    content: 'const wall = bim.create.addIfcWall(h, storey, { Start: [0,0,0] });',
+    revision: 7,
+    selection: { from: 0, to: 0 },
+  }, {
+    userPrompt: 'fix the revision conflict and keep the current script',
+    diagnostics: [
+      createPatchDiagnostic(
+        'patch_revision_conflict',
+        'Edit ops targeted revision 3 but the current editor revision is 4.',
+        'error',
+        { attemptedOpIds: ['declare-width-depth'] },
+      ),
+    ],
+  });
+
+  assert.match(prompt, /## CURRENT TASK FOCUS/);
+  assert.match(prompt, /Primary intent: `repair`/);
+  assert.match(prompt, /For repair turns, answer with patch blocks only and do not include a full runnable script fence/);
+  assert.match(prompt, /use them as anchors, but fix the stated root cause even if multiple related spans must change/);
+  assert.match(prompt, /Root causes:/);
+  assert.match(prompt, /\[root-cause:stale_patch_target\]/);
+  assert.match(prompt, /\[patch:patch_revision_conflict\] Edit ops targeted revision 3 but the current editor revision is 4/);
+});
+
+test('system prompt explains uploaded file runtime access', () => {
+  const prompt = buildSystemPrompt(undefined, [
+    {
+      id: 'entities-1',
+      name: 'entities-1.csv',
+      type: 'text/csv',
+      size: 256,
+      textContent: 'GlobalId,Description\nabc,Wall A\n',
+      csvColumns: ['GlobalId', 'Description'],
+      csvData: [{ GlobalId: 'abc', Description: 'Wall A' }],
+    },
+  ]);
+
+  assert.match(prompt, /UPLOADED FILES/);
+  assert.match(prompt, /bim\.files\.list\(\)/);
+  assert.match(prompt, /bim\.files\.csv\(name\)/);
+  assert.match(prompt, /Scripts can access the full attachment contents at runtime/);
+  assert.match(prompt, /Do not use `fetch\(\)` for chat attachments/);
+  assert.match(prompt, /Attachment-driven model edit \(common workflow\)/);
+  assert.match(prompt, /bim\.mutate\.setAttribute\(entity, "Description", byGuid\[guid\]\)/);
+  assert.match(prompt, /Type-level edit/);
+  assert.match(prompt, /const typeProps = bim\.query\.typeProperties\(wall\);/);
+  assert.match(prompt, /bim\.mutate\.setProperty\(typeProps\.type, "Pset_WallCommon", "Reference", "EXT"\)/);
+  assert.match(prompt, /bim\.export\.ifc\(entities, \{ filename: "updated\.ifc", includeMutations: true \}\)/);
+  assert.match(prompt, /Text preview:/);
+});