@alxxsck/ai-assistant 2.25.4 → 3.0.0

package/dist/api/audio.api.d.ts

@@ -16,5 +16,5 @@ export declare class AudioApiError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
-export declare const fetchProtectedAudio: (config: WidgetConfig, api: AppApi, request: ProtectedAudioRequest) => Promise<Blob>;
+export declare const fetchProtectedAudio: (config: WidgetConfig, api: AppApi, request: ProtectedAudioRequest, signal?: AbortSignal) => Promise<Blob>;
 export declare const fetchProtectedAudioStream: (config: WidgetConfig, api: AppApi, request: StreamingAudioRequest, signal: AbortSignal) => Promise<ReadableStream<Uint8Array>>;

package/dist/avatar/AnimationManager.d.ts

@@ -1,5 +1,6 @@
-import { Object3D, Group } from "three";
+import { Object3D } from "three";
 import type { Viseme } from "@/domain/speech/LipSyncRuntime";
+import { type AnimatedAsset } from "./loaders";
 import type { Avatar } from "./Avatar";
 export declare const BLEND_SHAPE_KEYS: readonly ["blendShape1.AE", "blendShape1.ChJ", "blendShape1.FV", "blendShape1.Oh", "blendShape1.Ah", "blendShape1.Ih", "blendShape1.L", "blendShape1.SZ", "blendShape1.Woo", "blendShape1.MBP", "blendShape1.Smile_Closed", "blendShape1.Smile_Open", "blendShape1.Kiss"];
 export type BlendShapeKey = (typeof BLEND_SHAPE_KEYS)[number];
@@ -16,7 +17,7 @@ type InitialAnimationAssets = {
     animationData: AnimationAssetsData;
     mandatoryAnimations: Array<{
         data: AnimationAsset;
-        animation: Group;
+        animation: AnimatedAsset;
     }>;
 };
 export default class AnimationManager {
@@ -29,9 +30,11 @@ export default class AnimationManager {
     private lazyAnimations;
     private animationLoads;
     private loadingManager;
-    private fbxLoader;
+    private animationLoader;
     private initialAssets;
     private backgroundPreloadCancelled;
+    private backgroundPreloadGeneration;
+    private backgroundPreloadComplete;
     private latestActionRequest;
     private pendingActionLoads;
     private idleFallbackPending;
@@ -47,6 +50,7 @@ export default class AnimationManager {
     private loadAnimationLazy;
     loadAction(name: string): Promise<void>;
     cancelBackgroundPreload(): void;
+    setBackgroundPreloadEnabled(enabled: boolean): void;
     private scheduleBackgroundPreload;
     private waitForBackgroundOpportunity;
     private preloadRemainingAnimations;

package/dist/avatar/Avatar.d.ts

@@ -1,5 +1,5 @@
 import { Mesh, Vector3 } from "three";
-import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
+import type { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import type { AppApi } from "@/App";
 import type { LipSyncSnapshot } from "@/domain/speech/LipSyncRuntime";
 import type { ExternallyAvailableActions } from "./publicAnimations";
@@ -9,12 +9,18 @@ type CameraParams = {
     lookAt: Vector3;
     fov: number;
 };
+export type AvatarFramingMode = "default" | "chat-surface";
 export declare class Avatar extends EventTarget {
     private canvas;
     private videoContainer;
     api: AppApi;
-    initialAssetsfbxLoader: FBXLoader;
+    initialAssetsLoader: GLTFLoader;
     head: Mesh;
+    /**
+     * The brows are a separate primitive in glTF but share the head's blend
+     * shapes, so they have to follow the same influences array. See syncFaceMorphs.
+     */
+    private brows?;
     private renderer;
     private sound?;
     private cubeTexture;
@@ -26,6 +32,7 @@ export declare class Avatar extends EventTarget {
     private body;
     private animationManager;
     private cameraParams;
+    private framingMode;
     private locale?;
     private animationFrame;
     private renderingEnabled;
@@ -33,6 +40,7 @@ export declare class Avatar extends EventTarget {
     constructor(canvas: HTMLCanvasElement, videoContainer: HTMLDivElement, api: AppApi);
     private lightAmbient;
     private lightDirectional;
+    private lightRim;
     private loadingManager;
     private criticalAssetsReady;
     private sounds;
@@ -40,13 +48,22 @@ export declare class Avatar extends EventTarget {
     init(): Promise<void>;
     initSounds(locale: string): void;
     private tempLookAt;
-    setCamera(params: CameraParams, cb?: () => void): void;
+    setCamera(params: CameraParams, cb?: () => void, duration?: number): void;
+    setFramingMode(mode: AvatarFramingMode): void;
     private width;
     private height;
     onResize: (width?: number, height?: number) => void;
     animate: () => void;
+    /**
+     * The head and the brows are two meshes sharing one set of blend shapes.
+     * Everything that drives the face (lip sync, blend shape scenarios, gsap
+     * tweens) writes into `head.morphTargetInfluences`, and some of it swaps the
+     * array outright, so the brows follow the head's current array every frame.
+     */
+    private syncFaceMorphs;
     setRenderingEnabled(enabled: boolean): void;
     cancelBackgroundPreload(): void;
+    setBackgroundPreloadEnabled(enabled: boolean): void;
     waitForCriticalAssets(): Promise<void>;
     private SPEAKING_ANIMATION_NAME_1;
     private SPEAKING_ANIMATION_NAME_2;

package/dist/avatar/avatarMeshes.d.ts

@@ -0,0 +1,8 @@
+import type { Object3D, SkinnedMesh } from "three";
+export type AvatarMeshSlot = "eyes" | "hair" | "head" | "brows" | "shell" | "body";
+export type AvatarMeshes = Partial<Record<AvatarMeshSlot, SkinnedMesh>>;
+/** Maps the meshes of a loaded avatar rig onto the slots the renderer knows about. */
+export declare function collectAvatarMeshes(root: Object3D): AvatarMeshes;
+/** Slots the avatar cannot render without. */
+export declare const REQUIRED_AVATAR_MESH_SLOTS: AvatarMeshSlot[];
+export declare function findMissingAvatarMeshes(meshes: AvatarMeshes): AvatarMeshSlot[];

package/dist/avatar/loaders.d.ts

@@ -0,0 +1,16 @@
+import type { AnimationClip, LoadingManager } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+/**
+ * Anything the avatar loads carries animation clips: the rig itself has none,
+ * an animation asset has exactly one. Narrowing to this shape keeps the call
+ * sites independent of whether a GLTF or a plain Object3D came back.
+ */
+export type AnimatedAsset = {
+    animations: AnimationClip[];
+};
+/**
+ * Avatar assets are glTF binaries compressed with EXT_meshopt_compression
+ * (see scripts/asset-pipeline/optimize-assets.mjs). The decoder ships its
+ * WebAssembly inline, so no extra file has to be served.
+ */
+export declare function createAvatarLoader(manager?: LoadingManager): GLTFLoader;

package/dist/bridge-ai-chat-widget.es.js

@@ -1,4 +1,4 @@
-import { C as A, E as e, S as s, d as E, c } from "./index-1DOqo2bD.js";
+import { C as A, E as e, S as s, d as E, c } from "./index-DY_Y_QHI.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,

package/dist/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const SM_BREAKPOINT = 640;
+export declare function isPhoneViewport(): boolean;
 export declare const SHOW_REACTION_MESSAGE_DURATION = 5000;

package/dist/context/ChatWidgetContext.d.ts

@@ -10,8 +10,6 @@ type ChatWidgetContextValue = {
     transitionSurface: (open: boolean, context: SurfaceTransitionContext) => void;
     openCompactPreview: (context: SurfaceTransitionContext) => Promise<boolean> | null;
     surfaceEpisodeId: string | null;
-    isFullscreen: boolean;
-    setFullscreen: (fullscreen: boolean) => void;
     contentActivated: boolean;
     isAvatarCoveredByChatList: boolean;
     setAvatarCoveredByChatList: (covered: boolean) => void;

package/dist/domain/client-environment/ClientEnvironmentRuntime.d.ts

@@ -0,0 +1,61 @@
+import type { CustomerInteractionSession } from "@/types";
+import { changeProjectionV1, collectClientEnvironmentV1 } from "./collectClientEnvironment";
+type ClientEnvironmentRuntimeOptions = Readonly<{
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    collect?: typeof collectClientEnvironmentV1;
+    project?: typeof changeProjectionV1;
+    createId?: () => string;
+    now?: () => number;
+    random?: () => number;
+    sdkVersion?: string;
+}>;
+export declare class ClientEnvironmentRuntime {
+    private readonly getSession;
+    private readonly onSessionExpired;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly collect;
+    private readonly project;
+    private readonly createId;
+    private readonly now;
+    private readonly random;
+    private readonly sdkVersion;
+    private sessionId;
+    private accessToken;
+    private generation;
+    private runtimeId;
+    private nextSequence;
+    private latestFenceRevision;
+    private lastStartedAt;
+    private cooldownUntil;
+    private lastCollectedProjection;
+    private acknowledged;
+    private active;
+    private pending;
+    private recovery;
+    private awaitingRenewalToken;
+    private currentProjectionUncertain;
+    private suppressedProjectionKey;
+    private pumpTimer;
+    private readonly eventWaiters;
+    private started;
+    private destroyed;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: ClientEnvironmentRuntimeOptions);
+    start(): void;
+    ensureForEvent(expectedSessionId: string): Promise<string | null>;
+    updateSession(session: CustomerInteractionSession): void;
+    destroy(): void;
+    private requestCurrentObservation;
+    private startRecovery;
+    private pump;
+    private upload;
+    private runAttempts;
+    private sendOnce;
+    private withEventDeadline;
+    private delay;
+    private resetGeneration;
+    private safeCreateId;
+    private cancelGeneration;
+}
+export {};

package/dist/domain/client-environment/collectClientEnvironment.d.ts

@@ -0,0 +1,6 @@
+import { type ClientEnvironmentBrowserSources, type ClientEnvironmentChangeProjectionV1, type ClientEnvironmentCollectionInput, type ClientEnvironmentObservationV1 } from "./types";
+export declare const CLIENT_ENVIRONMENT_BROWSER_INSTANCE_STORAGE_KEY = "lola-ai-assistant:client-environment:browser-instance:v1";
+export declare const browserClientEnvironmentSources: ClientEnvironmentBrowserSources;
+export declare const resolveClientEnvironmentBrowserInstanceId: (sources?: ClientEnvironmentBrowserSources) => string | null;
+export declare const collectClientEnvironmentV1: (input: ClientEnvironmentCollectionInput, sources?: ClientEnvironmentBrowserSources) => ClientEnvironmentObservationV1;
+export declare const changeProjectionV1: (observation: ClientEnvironmentObservationV1, previous?: ClientEnvironmentChangeProjectionV1 | null) => ClientEnvironmentChangeProjectionV1;

package/dist/domain/client-environment/types.d.ts

@@ -0,0 +1,93 @@
+export declare const CLIENT_ENVIRONMENT_SCHEMA_VERSION: 1;
+export declare const CLIENT_ENVIRONMENT_CHANGE_PROJECTION_VERSION: 1;
+export type ClientEnvironmentOrientation = "portrait" | "landscape" | "unknown";
+export interface ClientEnvironmentObservationV1 {
+    readonly schemaVersion: typeof CLIENT_ENVIRONMENT_SCHEMA_VERSION;
+    readonly clientObservationId: string;
+    readonly clientRuntimeId: string;
+    readonly clientSequence: number;
+    readonly browserInstanceId: string | null;
+    readonly collectedAt: string;
+    readonly sdk: Readonly<{
+        name: "lola-ai-assistant";
+        version: string;
+    }>;
+    readonly locale: Readonly<{
+        language: string | null;
+        languages: readonly string[];
+        timeZone: string | null;
+        localUtcOffsetMinutes: number | null;
+    }>;
+    readonly screen: Readonly<{
+        widthCssPx: number | null;
+        heightCssPx: number | null;
+        availableWidthCssPx: number | null;
+        availableHeightCssPx: number | null;
+        devicePixelRatio: number | null;
+        orientation: ClientEnvironmentOrientation;
+    }>;
+    readonly viewport: Readonly<{
+        widthCssPx: number | null;
+        heightCssPx: number | null;
+        visualWidthCssPx: number | null;
+        visualHeightCssPx: number | null;
+        visualScale: number | null;
+    }>;
+    readonly interaction: Readonly<{
+        maxTouchPoints: number | null;
+        coarsePointer: boolean | null;
+        hoverSupported: boolean | null;
+    }>;
+}
+export interface ClientEnvironmentCollectionInput {
+    readonly clientObservationId: string;
+    readonly clientRuntimeId: string;
+    readonly clientSequence: number;
+    readonly sdkVersion: string;
+}
+export interface BrowserInstanceStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface ClientEnvironmentBrowserSources {
+    readonly now: () => unknown;
+    readonly language: () => unknown;
+    readonly languages: () => unknown;
+    readonly timeZone: () => unknown;
+    readonly timeZoneOffsetMinutes: () => unknown;
+    readonly screenWidth: () => unknown;
+    readonly screenHeight: () => unknown;
+    readonly screenAvailableWidth: () => unknown;
+    readonly screenAvailableHeight: () => unknown;
+    readonly devicePixelRatio: () => unknown;
+    readonly screenOrientationType: () => unknown;
+    readonly viewportWidth: () => unknown;
+    readonly viewportHeight: () => unknown;
+    readonly visualViewportWidth: () => unknown;
+    readonly visualViewportHeight: () => unknown;
+    readonly visualViewportScale: () => unknown;
+    readonly maxTouchPoints: () => unknown;
+    readonly coarsePointer: () => unknown;
+    readonly hoverSupported: () => unknown;
+    readonly storage: () => BrowserInstanceStorage | null | undefined;
+    readonly randomUuid: () => unknown;
+}
+export interface ClientEnvironmentChangeProjectionV1 {
+    readonly projectionVersion: typeof CLIENT_ENVIRONMENT_CHANGE_PROJECTION_VERSION;
+    readonly browserInstanceId: string | null;
+    readonly language: string | null;
+    readonly languages: readonly string[];
+    readonly timeZone: string | null;
+    readonly localUtcOffsetMinutes: number | null;
+    readonly screenWidthCssPx: number | null;
+    readonly screenHeightCssPx: number | null;
+    readonly screenAvailableWidthCssPx: number | null;
+    readonly screenAvailableHeightCssPx: number | null;
+    readonly devicePixelRatio: number | null;
+    readonly orientation: ClientEnvironmentOrientation;
+    readonly viewportWidthBucketCssPx: number | null;
+    readonly visualScale: number | null;
+    readonly maxTouchPoints: number | null;
+    readonly coarsePointer: boolean | null;
+    readonly hoverSupported: boolean | null;
+}

package/dist/domain/command/CommandRuntime.d.ts

@@ -53,6 +53,7 @@ export declare class CommandRuntime {
     private requireEnvelopeTarget;
     private findTargetElement;
     private applyDefaultHighlight;
+    private applyHighlightEffect;
     private removeDefaultHighlight;
     private observeTarget;
     private createTargetActivationReporter;

package/dist/domain/message/message.store.d.ts

@@ -3,11 +3,14 @@ import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
 import { type MessageStreamState } from "./message-stream";
 import type { ChatAttachment, ChatTypingState } from "./chat-experience";
+import { type SafeResponderPresentation } from "@/domain/support-presentation/support-presentation.types";
 import type { ResponderPresentationChanged, ScenarioConversationCreated } from "./cable/widget-message";
 import { type ScenarioChoiceLifecycleChanged, type ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
 export interface ThreadSummary {
     threadId: string;
+    title: string | null;
     lastMessage: MessageData;
+    responderPresentation: SafeResponderPresentation;
 }
 export type AgentResponsePhase = "idle" | "awaiting-first-token" | "streaming";
 export type ConversationNavigationRequest = {

package/dist/domain/speech/SpeechPlayer.d.ts

@@ -1,6 +1,8 @@
 export type SpeechPlaybackOptions = {
     onStarted?: () => void;
     onStopped?: (completed: boolean) => void;
+    onLevel?: (level: number) => void;
+    levelContext?: AudioContext;
 };
 export type PcmStreamLoader = (signal: AbortSignal) => Promise<ReadableStream<Uint8Array>>;
 export type PcmPlaybackOptions = SpeechPlaybackOptions & {

package/dist/domain/tracking/LolaEventTracker.d.ts

@@ -1,4 +1,5 @@
 import type { CustomerInteractionSession } from "@/types";
+import type { ClientEnvironmentRuntime } from "@/domain/client-environment/ClientEnvironmentRuntime";
 export type TrackEvent = {
     event: string;
     params?: Record<string, unknown>;
@@ -6,6 +7,9 @@ export type TrackEvent = {
 export declare class LolaEventTracker {
     private readonly getSession;
     private readonly onSessionExpired;
-    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void);
+    private readonly clientEnvironment;
+    private destroyed;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, clientEnvironment: Pick<ClientEnvironmentRuntime, "ensureForEvent">);
     track(trackingEvent: TrackEvent): Promise<void>;
+    destroy(): void;
 }

package/dist/domain/ui/widget-geometry.d.ts

@@ -31,10 +31,11 @@ export type CompactPreviewLayout = {
 export declare const LAUNCHER_SIZE = 52;
 export declare const LAUNCHER_EDGE_INSET = 24;
 export declare const VIEWPORT_MARGIN = 16;
-export declare const MIN_WIDGET_WIDTH = 240;
-export declare const DEFAULT_WIDGET_WIDTH = 360;
-export declare const MIN_WIDGET_HEIGHT = 320;
+export declare const CHAT_SURFACE_ASPECT_RATIO: number;
+export declare const MIN_WIDGET_HEIGHT = 519;
+export declare const MIN_WIDGET_WIDTH: number;
 export declare const DEFAULT_WIDGET_HEIGHT = 680;
+export declare const DEFAULT_WIDGET_WIDTH: number;
 export declare const COMPACT_PREVIEW_MAX_WIDTH = 320;
 export declare const COMPACT_PREVIEW_MARGIN = 12;
 export declare const COMPACT_PREVIEW_GAP = 12;
@@ -45,7 +46,8 @@ export declare function dockLauncherPosition(point: Point, viewport: Viewport):
 export declare function launcherPointFromDock(launcher: DockedLauncher, viewport: Viewport): Point;
 export declare function clampLauncherPosition(point: Point, viewport: Viewport): Point;
 export declare function clampPanelRect(rect: Rect, viewport: Viewport): Rect;
+export declare function dockPanelRect(rect: Rect, viewport: Viewport): Rect;
+export declare function dockPanelRectToSide(rect: Rect, viewport: Viewport, side: LauncherSide): Rect;
 export declare function placePanelFromLauncher(launcher: Point, size: Size, viewport: Viewport): Rect;
 export declare function placeCompactPreview(launcher: Point, measuredSize: Size, viewport: Viewport, side: LauncherSide, avoidRect?: Rect | null): CompactPreviewLayout;
-export declare function resizePanelFromNorthWest(start: Rect, delta: Point, axes: "top" | "left" | "corner", viewport: Viewport): Rect;
-export declare function resizePanelFromSouthEast(start: Rect, delta: Point, viewport: Viewport): Rect;
+export declare function resizePanelFromTopCorner(start: Rect, delta: Point, corner: "northWest" | "northEast", viewport: Viewport): Rect;

package/dist/domain/voice/media/ReliableVoiceUplink.d.ts

@@ -6,10 +6,14 @@ export declare class ReliableVoiceUplink {
     private readonly queue;
     private sending;
     private closed;
+    private enabled;
+    private epoch;
     private firstCaptureSample;
     private firstDispatchAtMs;
     constructor(send: (chunk: CapturedAudioChunk) => Promise<VoiceAudioAcknowledgement>, onFailure: (error: Error) => void);
+    get isAcceptingInput(): boolean;
     enqueue(chunk: CapturedAudioChunk): void;
+    setEnabled(enabled: boolean): void;
     close(): void;
     private drain;
     private waitForPacing;

package/dist/domain/voice/voice-audio-meter.d.ts

@@ -0,0 +1,12 @@
+export type VoiceAudioMeterChannel = "input" | "output";
+type VoiceAudioMeterListener = (level: number) => void;
+export declare class VoiceAudioMeter {
+    private readonly levels;
+    private readonly listeners;
+    write(channel: VoiceAudioMeterChannel, value: unknown): void;
+    read(channel: VoiceAudioMeterChannel): number;
+    subscribe(channel: VoiceAudioMeterChannel, listener: VoiceAudioMeterListener): () => void;
+    reset(channel?: VoiceAudioMeterChannel): void;
+}
+export declare const voiceAudioMeter: VoiceAudioMeter;
+export {};

package/dist/domain/voice/voice.store.d.ts

@@ -1,6 +1,7 @@
 import { type Socket } from "socket.io-client";
 import type { AppApi } from "@/App";
 import type { VoiceSessionData } from "@/api/voice.api.types";
+import { ReliableVoiceUplink } from "./media/ReliableVoiceUplink";
 import type { SpeakTextCommandContext, StartVoiceConversationCommandContext } from "@/domain/command/command.types";
 import type { WidgetConfig } from "@/index.types";
 type VoiceStatus = "idle" | "connecting" | "listening" | "speaking" | "error";
@@ -16,20 +17,23 @@ type VoiceStore = {
     localStream: MediaStream | null;
     inputAudioContext: AudioContext | null;
     inputAudioNode: AudioWorkletNode | null;
+    inputAudioUplink: ReliableVoiceUplink | null;
     pendingInvitation: StartVoiceConversationCommandContext | null;
     customerMessageTranscript: string;
     customerMessageTranscriptVisible: boolean;
     assistantMessageTranscript: string;
     assistantMessageTranscriptVisible: boolean;
     assistantResponseInProgress: boolean;
+    assistantAudioPlaying: boolean;
     microphoneEnabled: boolean;
+    microphoneMutedByUser: boolean;
     generation: number;
     actions: VoiceStoreActions;
 };
 type VoiceStoreActions = {
     updateSession: (config: WidgetConfig, api: AppApi) => Promise<void>;
     startListening: (config: WidgetConfig, api: AppApi) => Promise<void>;
-    offerConversation: (invitation: StartVoiceConversationCommandContext) => Promise<void>;
+    offerConversation: (invitation: StartVoiceConversationCommandContext, config: WidgetConfig, api: AppApi) => Promise<void>;
     acceptConversation: (config: WidgetConfig, api: AppApi) => Promise<void>;
     declineConversation: (config: WidgetConfig, api: AppApi) => Promise<void>;
     speakText: (config: WidgetConfig, api: AppApi, speech: SpeakTextCommandContext) => Promise<void>;

package/dist/i18n/messages.d.ts

@@ -14,6 +14,7 @@ declare const en: {
     };
     readonly controls: {
         readonly close: "Close chat";
+        readonly collapse: "Collapse chat";
         readonly move: "Move Lola";
         readonly exitFullscreen: "Exit fullscreen";
         readonly enterFullscreen: "Enter fullscreen";
@@ -25,6 +26,7 @@ declare const en: {
     readonly identity: {
         readonly support: "Support";
         readonly system: "System";
+        readonly online: "online";
         readonly aiAssistant: "AI assistant";
         readonly waiting: "Waiting for a specialist";
         readonly operator: "Support operator";
@@ -33,8 +35,9 @@ declare const en: {
     };
     readonly chat: {
         readonly back: "Back to chat";
-        readonly listTitle: "Chats";
+        readonly listTitle: "Chat history";
         readonly new: "New chat";
+        readonly createNew: "Create new chat";
         readonly loadOlder: "Load older chats";
         readonly retryOlder: "Retry older chats";
         readonly olderLoadFailed: "Couldn't load older chats.";
@@ -47,7 +50,7 @@ declare const en: {
         readonly switchToVoice: "Switch to voice chat";
         readonly talk: "Talk";
         readonly messageLabel: "Message";
-        readonly messagePlaceholder: "Message…";
+        readonly messagePlaceholder: "Write to Lola";
         readonly send: "Send message";
         readonly thinking: "AI is thinking";
         readonly unread: "Unread messages";