@foisit/angular-wrapper 2.4.4 → 2.4.5

package/fesm2022/foisit-angular-wrapper.mjs

@@ -1,288 +1,2102 @@
-import * as i0 from '@angular/core';
-import { Component, Inject, Injectable, NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { CommandHandler, FallbackHandler, VoiceProcessor, TextToSpeech, StateManager, GestureHandler, OverlayManager } from '@foisit/core';
-
-class AngularWrapperComponent {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AngularWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.7", type: AngularWrapperComponent, isStandalone: true, selector: "lib-angular-wrapper", ngImport: i0, template: "<p>AngularWrapper works!</p>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AngularWrapperComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'lib-angular-wrapper', imports: [CommonModule], template: "<p>AngularWrapper works!</p>\n" }]
-        }] });
-
-class AssistantService {
-    config;
-    commandHandler;
-    fallbackHandler;
-    voiceProcessor;
-    textToSpeech;
-    stateManager;
-    lastProcessedInput = '';
-    processingLock = false;
-    isActivated = false; // Tracks activation status
-    gestureHandler;
-    overlayManager;
-    defaultIntroMessage = 'How can I help you?';
-    constructor(config) {
-        this.config = config;
-        // Pass enableSmartIntent (default true) and potential apiKey (if we add it to config later)
-        this.commandHandler = new CommandHandler({
-            enableSmartIntent: this.config.enableSmartIntent !== false,
-            intentEndpoint: this.config.intentEndpoint,
-        });
-        this.fallbackHandler = new FallbackHandler();
-        this.voiceProcessor = new VoiceProcessor();
-        this.textToSpeech = new TextToSpeech();
-        this.stateManager = new StateManager();
-        this.gestureHandler = new GestureHandler();
-        this.overlayManager = new OverlayManager({
-            floatingButton: this.config.floatingButton,
-            inputPlaceholder: this.config.inputPlaceholder,
+// dist/libs/angular-wrapper/fesm2022/foisit-angular-wrapper.mjs
+import * as i0 from "@angular/core";
+import { Component, Inject, Injectable, NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+
+// dist/libs/core/src/lib/command/command-handler.js
+import { __awaiter as __awaiter2 } from "tslib";
+
+// dist/libs/core/src/lib/ai/openai.service.js
+import { __awaiter } from "tslib";
+var OpenAIService = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint || "https://foisit-ninja.netlify.app/.netlify/functions/intent";
+  }
+  determineIntent(userInput, availableCommands, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const payload = {
+          userInput,
+          commands: availableCommands.map((cmd) => ({
+            id: cmd.id,
+            command: cmd.command,
+            description: cmd.description,
+            parameters: cmd.parameters
+            // Send param schemas to AI
+          })),
+          context
+        };
+        const response = yield fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
         });
-        // Setup commands from config
-        this.config.commands.forEach((cmd) => this.commandHandler.addCommand(cmd));
-        // Setup fallback response
-        if (this.config.fallbackResponse) {
-            this.fallbackHandler.setFallbackMessage(this.config.fallbackResponse);
-        }
-        // Voice disabled for text-first pivot
-        // this.startListening();
-        // Setup double-tap/double-click listener
-        this.gestureHandler.setupDoubleTapListener(() => this.toggle());
-        // Register global callbacks for floating button
-        this.overlayManager.registerCallbacks(async (input) => {
-            if (typeof input === 'string') {
-                this.overlayManager.addMessage(input, 'user');
-            }
-            else if (input && typeof input === 'object') {
-                const label = this.extractUserLabel(input);
-                if (label) {
-                    this.overlayManager.addMessage(label, 'user');
-                }
-            }
-            await this.handleCommand(input);
-        }, () => console.log('AssistantService: Overlay closed.'));
+        if (!response.ok) {
+          throw new Error(`Proxy API Error: ${response.statusText}`);
+        }
+        const result = yield response.json();
+        return result;
+      } catch (error) {
+        console.error("OpenAIService Error:", error);
+        return { type: "unknown" };
+      }
+    });
+  }
+};
+
+// dist/libs/core/src/lib/command/command-handler.js
+var CommandHandler = class {
+  constructor(arg = true) {
+    var _a;
+    this.commands = /* @__PURE__ */ new Map();
+    this.openAIService = null;
+    this.context = null;
+    this.pendingConfirmation = null;
+    this.enableSmartIntent = true;
+    this.selectOptionsCache = /* @__PURE__ */ new Map();
+    if (typeof arg === "boolean") {
+      this.enableSmartIntent = arg;
+      if (this.enableSmartIntent) {
+        this.openAIService = new OpenAIService();
+      }
+      return;
     }
-    /** Start listening for activation and commands */
-    startListening() {
-        // Voice is currently disabled (text-only mode)
-        console.log('AssistantService: Voice is disabled; startListening() is a no-op.');
-        return;
-        /*
-        this.voiceProcessor.startListening(async (transcript: string) => {
-          if (this.processingLock) return;
-    
-          const normalizedTranscript = transcript.toLowerCase().trim();
-    
-          // Skip repeated or irrelevant inputs
-          if (
-            !normalizedTranscript ||
-            normalizedTranscript.length < 3 ||
-            normalizedTranscript === this.lastProcessedInput
-          ) {
-            console.log('AssistantService: Ignoring irrelevant input.');
-            return;
+    this.enableSmartIntent = (_a = arg.enableSmartIntent) !== null && _a !== void 0 ? _a : true;
+    if (this.enableSmartIntent) {
+      this.openAIService = new OpenAIService(arg.intentEndpoint);
+    }
+  }
+  /** Add a new command (string or object) */
+  addCommand(commandOrObj, action) {
+    let cmd;
+    if (typeof commandOrObj === "string") {
+      if (!action) {
+        throw new Error("Action required when adding command by string.");
+      }
+      cmd = {
+        id: commandOrObj.toLowerCase().replace(/\s+/g, "_"),
+        command: commandOrObj.toLowerCase(),
+        action
+      };
+    } else {
+      cmd = Object.assign({}, commandOrObj);
+      if (!cmd.id) {
+        cmd.id = cmd.command.toLowerCase().replace(/\s+/g, "_");
+      }
+    }
+    this.commands.set(cmd.command.toLowerCase(), cmd);
+    if (cmd.id && cmd.id !== cmd.command) {
+    }
+  }
+  /** Remove an existing command */
+  removeCommand(command) {
+    this.commands.delete(command.toLowerCase());
+  }
+  /** Execute a command by matching input */
+  executeCommand(input) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      var _a, _b, _c;
+      if (typeof input === "object" && input !== null) {
+        if (this.isStructured(input)) {
+          const cmdId = String(input.commandId);
+          const rawParams = (_a = input.params) !== null && _a !== void 0 ? _a : {};
+          const cmd2 = this.getCommandById(cmdId);
+          if (!cmd2)
+            return { message: "That command is not available.", type: "error" };
+          const params = this.sanitizeParamsForCommand(cmd2, rawParams);
+          const requiredParams = ((_b = cmd2.parameters) !== null && _b !== void 0 ? _b : []).filter((p) => p.required);
+          const missing = requiredParams.filter((p) => params[p.name] == null || params[p.name] === "");
+          if (missing.length > 0) {
+            this.context = { commandId: this.getCommandIdentifier(cmd2), params };
+            return {
+              message: `Please provide the required details for "${cmd2.command}".`,
+              type: "form",
+              fields: missing
+            };
           }
-    
-          this.lastProcessedInput = normalizedTranscript;
-    
-          if (!this.isActivated) {
-            await this.processActivation(normalizedTranscript);
-            return;
+          if (cmd2.critical) {
+            this.pendingConfirmation = { commandId: this.getCommandIdentifier(cmd2), params };
+            return this.buildConfirmResponse(cmd2);
           }
-    
-          const isFallbackOrIntroMessage =
-            normalizedTranscript === this.config.fallbackResponse?.toLowerCase() ||
-            normalizedTranscript === this.config.introMessage?.toLowerCase() ||
-            normalizedTranscript === this.defaultIntroMessage.toLowerCase();
-    
-          if (!isFallbackOrIntroMessage) {
-            await this.handleCommand(normalizedTranscript);
+          return this.safeRunAction(cmd2, params);
+        }
+        if (!this.context) {
+          return { message: "Session expired or invalid context.", type: "error" };
+        }
+        const cmd = this.getCommandById(this.context.commandId);
+        if (!cmd) {
+          this.context = null;
+          return { message: "Session expired or invalid context.", type: "error" };
+        }
+        if (Array.isArray(input)) {
+          return { message: "Invalid form payload.", type: "error" };
+        }
+        const mergedParams = Object.assign(Object.assign({}, this.context.params), input);
+        if (cmd.critical) {
+          this.context = null;
+          this.pendingConfirmation = {
+            commandId: this.getCommandIdentifier(cmd),
+            params: mergedParams
+          };
+          return this.buildConfirmResponse(cmd);
+        }
+        const result = yield this.safeRunAction(cmd, mergedParams);
+        this.context = null;
+        return this.normalizeResponse(result);
+      }
+      const trimmedInput = input.trim().toLowerCase();
+      if (this.pendingConfirmation) {
+        const normalized = trimmedInput;
+        if (["yes", "y", "confirm", "ok", "okay"].includes(normalized)) {
+          const { commandId, params } = this.pendingConfirmation;
+          this.pendingConfirmation = null;
+          const cmd = this.getCommandById(commandId);
+          if (!cmd) {
+            return { message: "That action is no longer available.", type: "error" };
+          }
+          return this.safeRunAction(cmd, params);
+        }
+        if (["no", "n", "cancel", "stop"].includes(normalized)) {
+          this.pendingConfirmation = null;
+          return { message: "Cancelled.", type: "success" };
+        }
+        return {
+          message: "Please confirm: Yes or No.",
+          type: "confirm",
+          options: [
+            { label: "Yes", value: "yes" },
+            { label: "No", value: "no" }
+          ]
+        };
+      }
+      const exactCommand = this.commands.get(trimmedInput);
+      if (exactCommand) {
+        const cmd = exactCommand;
+        const requiredParams = ((_c = cmd.parameters) !== null && _c !== void 0 ? _c : []).filter((p) => p.required);
+        if (requiredParams.length > 0) {
+          this.context = { commandId: this.getCommandIdentifier(cmd), params: {} };
+          return {
+            message: `Please provide the required details for "${cmd.command}".`,
+            type: "form",
+            fields: requiredParams
+          };
+        }
+        if (cmd.critical) {
+          this.pendingConfirmation = { commandId: this.getCommandIdentifier(cmd), params: {} };
+          return this.buildConfirmResponse(cmd);
+        }
+        return this.safeRunAction(cmd, {});
+      }
+      const deterministic = yield this.tryDeterministicMatch(trimmedInput);
+      if (deterministic)
+        return deterministic;
+      if (this.enableSmartIntent && this.openAIService) {
+        const availableCommands = yield this.getCommandsForAI();
+        const aiResult = yield this.openAIService.determineIntent(trimmedInput, availableCommands, this.context);
+        return this.handleAIResult(aiResult);
+      }
+      if (!this.enableSmartIntent) {
+        return { message: "I'm not sure what you mean.", type: "error" };
+      }
+      return this.listAllCommands();
+    });
+  }
+  handleAIResult(result) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      var _a, _b;
+      if (result.type === "match" && result.match) {
+        const cmd = this.getCommandById(result.match);
+        if (!cmd) {
+          return { message: "I'm not sure what you mean.", type: "error" };
+        }
+        const rawParams = (_a = result.params) !== null && _a !== void 0 ? _a : {};
+        const sanitizedParams = this.sanitizeParamsForCommand(cmd, rawParams);
+        const params = cmd.allowAiParamExtraction === false ? {} : sanitizedParams;
+        const requiredParams = ((_b = cmd.parameters) !== null && _b !== void 0 ? _b : []).filter((p) => p.required);
+        const missingRequired = requiredParams.filter((p) => params[p.name] == null || params[p.name] === "");
+        if (result.incomplete || missingRequired.length > 0) {
+          this.context = { commandId: this.getCommandIdentifier(cmd), params };
+          const mustUseForm = cmd.collectRequiredViaForm !== false;
+          const askSingle = !mustUseForm && this.shouldAskSingleQuestion(missingRequired);
+          if (askSingle) {
+            const names = missingRequired.map((p) => p.name).join(" and ");
+            return {
+              message: result.message || `Please provide ${names}.`,
+              type: "question"
+            };
+          }
+          return {
+            message: result.message || `Please fill in the missing details for "${cmd.command}".`,
+            type: "form",
+            fields: missingRequired
+          };
+        }
+        if (cmd.critical) {
+          this.pendingConfirmation = {
+            commandId: this.getCommandIdentifier(cmd),
+            params
+          };
+          return this.buildConfirmResponse(cmd);
+        }
+        const actionResult = yield cmd.action(params);
+        return this.normalizeResponse(actionResult);
+      }
+      if (result.type === "ambiguous" && result.options && result.options.length) {
+        return {
+          message: result.message || "Did you mean one of these?",
+          type: "ambiguous",
+          options: result.options.map((o) => {
+            var _a2;
+            return {
+              label: o.label,
+              value: (_a2 = o.commandId) !== null && _a2 !== void 0 ? _a2 : o.label,
+              commandId: o.commandId
+            };
+          })
+        };
+      }
+      return this.listAllCommands();
+    });
+  }
+  sanitizeParamsForCommand(cmd, params) {
+    var _a, _b;
+    const sanitized = Object.assign({}, params !== null && params !== void 0 ? params : {});
+    for (const p of (_a = cmd.parameters) !== null && _a !== void 0 ? _a : []) {
+      const value = sanitized[p.name];
+      if (p.type === "string") {
+        if (typeof value !== "string") {
+          delete sanitized[p.name];
+          continue;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+          delete sanitized[p.name];
+          continue;
+        }
+        sanitized[p.name] = trimmed;
+      }
+      if (p.type === "number") {
+        const numeric = typeof value === "number" ? value : Number(value === null || value === void 0 ? void 0 : value.toString().trim());
+        if (Number.isNaN(numeric)) {
+          delete sanitized[p.name];
+          continue;
+        }
+        if (typeof p.min === "number" && numeric < p.min) {
+          delete sanitized[p.name];
+          continue;
+        }
+        if (typeof p.max === "number" && numeric > p.max) {
+          delete sanitized[p.name];
+          continue;
+        }
+        sanitized[p.name] = numeric;
+      }
+      if (p.type === "date") {
+        const v = sanitized[p.name];
+        if (typeof v === "string") {
+          const s = v.trim();
+          if (!this.isIsoDateString(s)) {
+            delete sanitized[p.name];
           } else {
-            console.log('AssistantService: Ignoring fallback or intro message.');
+            sanitized[p.name] = s;
           }
-    
-          // Throttle input processing to prevent rapid feedback
-          this.processingLock = true;
-          setTimeout(() => (this.processingLock = false), 1000);
-        });
-        */
-    }
-    /** Stop listening for voice input */
-    stopListening() {
-        // Voice is currently disabled (text-only mode)
-        console.log('AssistantService: Voice is disabled; stopListening() is a no-op.');
-        this.isActivated = false;
-    }
-    /** Reset activation state so the next activation flow can occur. */
-    reactivate() {
-        console.log('AssistantService: Reactivating assistant...');
-        this.isActivated = false;
-        try {
-            this.startListening();
+        } else {
+          delete sanitized[p.name];
+        }
+      }
+      if (p.type === "select") {
+        const v = typeof value === "string" ? value : value === null || value === void 0 ? void 0 : value.toString();
+        if (!v) {
+          delete sanitized[p.name];
+          continue;
         }
-        catch {
-            // no-op
+        if (Array.isArray(p.options) && p.options.length > 0) {
+          const allowed = p.options.some((opt) => String(opt.value) === String(v));
+          if (!allowed) {
+            delete sanitized[p.name];
+            continue;
+          }
+        }
+        sanitized[p.name] = v;
+      }
+      if (p.type === "file") {
+        const val = sanitized[p.name];
+        const isFileLike = val && typeof val === "object" && typeof val.name === "string" && typeof val.size === "number";
+        const isDataUrl = typeof val === "string" && /^data:[^;]+;base64,/.test(val);
+        const delivery = (_b = p.delivery) !== null && _b !== void 0 ? _b : "file";
+        if (delivery === "base64") {
+          if (!isDataUrl && !isFileLike) {
+            delete sanitized[p.name];
+          }
+        } else {
+          if (!isFileLike) {
+            delete sanitized[p.name];
+          }
         }
+      }
     }
-    /** Process activation command */
-    async processActivation(transcript) {
-        const activationCmd = this.config.activationCommand?.toLowerCase();
-        // If no activation command is set, we can't activate via voice
-        if (!activationCmd)
+    return sanitized;
+  }
+  isIsoDateString(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+      return false;
+    const dt = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+    return !Number.isNaN(dt.getTime());
+  }
+  shouldAskSingleQuestion(missing) {
+    if (missing.length !== 1)
+      return false;
+    const t = missing[0].type;
+    return t === "string" || t === "number" || t === "date";
+  }
+  buildConfirmResponse(cmd) {
+    return {
+      message: `Are you sure you want to run "${cmd.command}"?`,
+      type: "confirm",
+      options: [
+        { label: "Yes", value: "yes" },
+        { label: "No", value: "no" }
+      ]
+    };
+  }
+  tryDeterministicMatch(input) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      var _a, _b;
+      const candidates = [];
+      for (const cmd2 of this.commands.values()) {
+        let score = 0;
+        const commandPhrase = cmd2.command.toLowerCase();
+        if (input.includes(commandPhrase))
+          score += 5;
+        const keywords = (_a = cmd2.keywords) !== null && _a !== void 0 ? _a : [];
+        for (const kw of keywords) {
+          const k = kw.toLowerCase().trim();
+          if (!k)
+            continue;
+          if (input === k)
+            score += 4;
+          else if (input.includes(k))
+            score += 3;
+        }
+        if (score > 0)
+          candidates.push({ cmd: cmd2, score });
+      }
+      if (candidates.length === 0)
+        return null;
+      candidates.sort((a, b) => b.score - a.score);
+      const topScore = candidates[0].score;
+      const top = candidates.filter((c) => c.score === topScore).slice(0, 3);
+      if (top.length > 1) {
+        return {
+          message: "I think you mean one of these. Which one should I run?",
+          type: "ambiguous",
+          options: top.map((c) => ({
+            label: c.cmd.command,
+            value: c.cmd.command,
+            commandId: c.cmd.id
+          }))
+        };
+      }
+      const cmd = top[0].cmd;
+      const requiredParams = ((_b = cmd.parameters) !== null && _b !== void 0 ? _b : []).filter((p) => p.required);
+      if (requiredParams.length > 0) {
+        this.context = { commandId: this.getCommandIdentifier(cmd), params: {} };
+        return {
+          message: `Please provide the required details for "${cmd.command}".`,
+          type: "form",
+          fields: requiredParams
+        };
+      }
+      if (cmd.critical) {
+        this.pendingConfirmation = { commandId: this.getCommandIdentifier(cmd), params: {} };
+        return this.buildConfirmResponse(cmd);
+      }
+      return this.safeRunAction(cmd, {});
+    });
+  }
+  safeRunAction(cmd, params) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      try {
+        const result = yield cmd.action(params !== null && params !== void 0 ? params : {});
+        return this.normalizeResponse(result);
+      } catch (_a) {
+        return { message: "Something went wrong while running that command.", type: "error" };
+      }
+    });
+  }
+  getCommandsForAI() {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const commands = Array.from(this.commands.values()).map((cmd) => Object.assign(Object.assign({}, cmd), { parameters: cmd.parameters ? cmd.parameters.map((param) => Object.assign({}, param)) : void 0 }));
+      yield Promise.all(commands.map((cmd) => __awaiter2(this, void 0, void 0, function* () {
+        if (!cmd.parameters)
+          return;
+        yield Promise.all(cmd.parameters.map((p) => __awaiter2(this, void 0, void 0, function* () {
+          var _a;
+          if (p.type !== "select" || !p.getOptions || p.options && p.options.length)
+            return;
+          const cacheKey = `${(_a = cmd.id) !== null && _a !== void 0 ? _a : cmd.command}:${p.name}`;
+          const cached = this.selectOptionsCache.get(cacheKey);
+          const now = Date.now();
+          if (cached && now - cached.ts < 6e4) {
+            p.options = cached.options;
             return;
-        if (transcript === activationCmd) {
-            console.log('AssistantService: Activation matched.');
-            this.isActivated = true;
-            this.textToSpeech.speak(this.config.introMessage || this.defaultIntroMessage);
-            // this.stateManager.setState('listening'); // DISABLED - no gradient animation
+          }
+          try {
+            const opts = yield p.getOptions();
+            this.selectOptionsCache.set(cacheKey, { options: opts, ts: now });
+            p.options = opts;
+          } catch (_b) {
+          }
+        })));
+      })));
+      return commands;
+    });
+  }
+  getCommandById(id) {
+    for (const cmd of this.commands.values()) {
+      if (cmd.id === id)
+        return cmd;
+    }
+    return void 0;
+  }
+  listAllCommands() {
+    const options = Array.from(this.commands.values()).map((cmd) => {
+      var _a, _b;
+      return {
+        label: cmd.command,
+        value: (_a = cmd.id) !== null && _a !== void 0 ? _a : cmd.command,
+        commandId: (_b = cmd.id) !== null && _b !== void 0 ? _b : cmd.command
+      };
+    });
+    return {
+      message: "Here are the available commands:",
+      type: "ambiguous",
+      options
+    };
+  }
+  normalizeResponse(result) {
+    if (typeof result === "string") {
+      return { message: result, type: "success" };
+    }
+    if (result && typeof result === "object") {
+      return result;
+    }
+    return { message: "Done", type: "success" };
+  }
+  isStructured(input) {
+    return typeof input["commandId"] === "string";
+  }
+  getCommandIdentifier(cmd) {
+    if (!cmd.id) {
+      cmd.id = cmd.command.toLowerCase().replace(/\s+/g, "_");
+    }
+    return cmd.id;
+  }
+  /** List all registered commands */
+  getCommands() {
+    return Array.from(this.commands.keys());
+  }
+};
+
+// dist/libs/core/src/lib/speech/text-to-speech.js
+var TextToSpeech = class {
+  constructor() {
+    this.synth = window.speechSynthesis;
+  }
+  speak(text, options) {
+    if (!this.synth) {
+      console.error("SpeechSynthesis API is not supported in this browser.");
+      return;
+    }
+    const utterance = new SpeechSynthesisUtterance(text);
+    if (options) {
+      utterance.pitch = options.pitch || 1;
+      utterance.rate = options.rate || 1;
+      utterance.volume = options.volume || 1;
+    }
+    utterance.onstart = () => {
+      window.dispatchEvent(new CustomEvent("foisit:tts-start"));
+    };
+    utterance.onend = () => {
+      console.log("Speech finished.");
+      window.dispatchEvent(new CustomEvent("foisit:tts-end"));
+    };
+    utterance.onerror = (event) => {
+      console.error("Error during speech synthesis:", event.error);
+    };
+    this.synth.speak(utterance);
+  }
+  stopSpeaking() {
+    if (this.synth) {
+      this.synth.cancel();
+    }
+  }
+};
+
+// dist/libs/core/src/lib/fallback/fallback-handler.js
+var FallbackHandler = class {
+  constructor() {
+    this.fallbackMessage = "Sorry, I didn\u2019t understand that.";
+  }
+  setFallbackMessage(message) {
+    this.fallbackMessage = message;
+  }
+  handleFallback(transcript) {
+    if (transcript)
+      console.log(`Fallback triggered for: "${transcript}"`);
+    console.log(this.fallbackMessage);
+    new TextToSpeech().speak(this.fallbackMessage);
+  }
+  getFallbackMessage() {
+    return this.fallbackMessage;
+  }
+};
+
+// dist/libs/core/src/lib/speech/voice-processor.js
+import { __awaiter as __awaiter3 } from "tslib";
+var getRecognitionCtor = () => {
+  var _a, _b;
+  const w = window;
+  return (_b = (_a = w.SpeechRecognition) !== null && _a !== void 0 ? _a : w.webkitSpeechRecognition) !== null && _b !== void 0 ? _b : null;
+};
+var VoiceProcessor = class {
+  // Debug logger helpers
+  log(message) {
+    if (this.debugEnabled && message) {
+      console.log("[VoiceProcessor]", message);
+    }
+  }
+  warn(message) {
+    if (this.debugEnabled && message) {
+      console.warn("[VoiceProcessor]", message);
+    }
+  }
+  error(message) {
+    if (this.debugEnabled && message) {
+      console.error("[VoiceProcessor]", message);
+    }
+  }
+  constructor(language = "en-US", options = {}) {
+    var _a, _b;
+    this.recognition = null;
+    this.isListening = false;
+    this.engineActive = false;
+    this.intentionallyStopped = false;
+    this.restartAllowed = true;
+    this.lastStart = 0;
+    this.backoffMs = 250;
+    this.destroyed = false;
+    this.resultCallback = null;
+    this.ttsSpeaking = false;
+    this.debugEnabled = true;
+    this.restartTimer = null;
+    this.prewarmed = false;
+    this.hadResultThisSession = false;
+    this.onTTSStart = () => {
+      var _a2;
+      this.ttsSpeaking = true;
+      try {
+        (_a2 = this.recognition) === null || _a2 === void 0 ? void 0 : _a2.stop();
+      } catch (_b2) {
+      }
+      if (this.isListening) {
+        this.emitStatus("speaking");
+      }
+    };
+    this.onTTSEnd = () => {
+      this.ttsSpeaking = false;
+      if (this.isListening && this.restartAllowed) {
+        this.safeRestart();
+      } else {
+        this.emitStatus(this.isListening ? "listening" : "idle");
+      }
+    };
+    const Ctor = getRecognitionCtor();
+    if (Ctor) {
+      this.recognition = new Ctor();
+      this.recognition.lang = language;
+      this.recognition.interimResults = (_a = options.interimResults) !== null && _a !== void 0 ? _a : true;
+      this.recognition.continuous = (_b = options.continuous) !== null && _b !== void 0 ? _b : true;
+      this.recognition.onresult = (event) => this.handleResult(event, options);
+      this.recognition.onend = () => this.handleEnd();
+      this.recognition.onstart = () => {
+        this.log("recognition onstart");
+        this.engineActive = true;
+        this.hadResultThisSession = false;
+        if (this.restartTimer) {
+          clearTimeout(this.restartTimer);
+          this.restartTimer = null;
         }
-        else {
-            console.log('AssistantService: Activation command not recognized.');
+        this.backoffMs = 250;
+        if (this.isListening && !this.ttsSpeaking) {
+          this.emitStatus("listening");
         }
+      };
+      const vrec = this.recognition;
+      vrec.onaudiostart = () => this.log("onaudiostart");
+      vrec.onsoundstart = () => this.log("onsoundstart");
+      vrec.onspeechstart = () => this.log("onspeechstart");
+      vrec.onspeechend = () => this.log("onspeechend");
+      vrec.onsoundend = () => this.log("onsoundend");
+      vrec.onaudioend = () => this.log("onaudioend");
+      this.recognition.onerror = (event) => this.handleError(event);
+    } else {
+      this.recognition = null;
+      this.emitStatus("unsupported");
     }
-    /** Handle recognized commands */
-    async handleCommand(input) {
-        this.overlayManager.showLoading();
-        let response;
+    window.addEventListener("foisit:tts-start", this.onTTSStart);
+    window.addEventListener("foisit:tts-end", this.onTTSEnd);
+    this.visibilityHandler = () => {
+      var _a2;
+      if (document.hidden) {
         try {
-            response = await this.commandHandler.executeCommand(input);
-        }
-        finally {
-            this.overlayManager.hideLoading();
-        }
-        const originalText = typeof input === 'string' ? input : undefined;
-        this.processResponse(response, originalText);
-    }
-    /**
-     * Cleanup resources
-     */
-    destroy() {
-        this.voiceProcessor.stopListening();
-        this.gestureHandler.destroy();
-        this.overlayManager.destroy();
-    }
-    /** Unified response processing */
-    processResponse(response, originalText) {
-        if (response.type === 'error' && originalText) {
-            this.fallbackHandler.handleFallback(originalText);
-            this.overlayManager.addMessage(this.fallbackHandler.getFallbackMessage(), 'system');
+          (_a2 = this.recognition) === null || _a2 === void 0 ? void 0 : _a2.stop();
+        } catch (_b2) {
+        }
+        this.emitStatus(this.ttsSpeaking ? "speaking" : "idle");
+      } else if (this.isListening && !this.ttsSpeaking) {
+        this.safeRestart();
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  /** Check if SpeechRecognition is available */
+  isSupported() {
+    return getRecognitionCtor() !== null;
+  }
+  /** Allow consumers (wrappers) to observe status changes */
+  onStatusChange(callback) {
+    this.statusCallback = callback;
+  }
+  /** Start listening for speech input */
+  startListening(callback) {
+    if (!this.isSupported() || !this.recognition) {
+      this.warn("VoiceProcessor: SpeechRecognition is not supported in this browser.");
+      this.emitStatus("unsupported");
+      return;
+    }
+    if (this.isListening) {
+      this.warn("VoiceProcessor: Already listening.");
+      this.resultCallback = callback;
+      return;
+    }
+    this.resultCallback = callback;
+    this.intentionallyStopped = false;
+    this.restartAllowed = true;
+    this.isListening = true;
+    this.emitStatus("listening");
+    this.prewarmAudio().finally(() => {
+      this.safeRestart();
+    });
+  }
+  /** Stop listening for speech input */
+  stopListening() {
+    var _a;
+    this.intentionallyStopped = true;
+    this.restartAllowed = false;
+    this.isListening = false;
+    this.emitStatus(this.ttsSpeaking ? "speaking" : "idle");
+    try {
+      (_a = this.recognition) === null || _a === void 0 ? void 0 : _a.stop();
+    } catch (_b) {
+    }
+  }
+  /** Clean up listeners */
+  destroy() {
+    this.destroyed = true;
+    this.stopListening();
+    this.resultCallback = null;
+    window.removeEventListener("foisit:tts-start", this.onTTSStart);
+    window.removeEventListener("foisit:tts-end", this.onTTSEnd);
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = void 0;
+    }
+  }
+  /** Handle recognized speech results */
+  handleResult(event, options) {
+    var _a, _b, _c, _d;
+    if (!this.resultCallback)
+      return;
+    const threshold = (_a = options.confidenceThreshold) !== null && _a !== void 0 ? _a : 0.6;
+    for (let i = event.resultIndex; i < event.results.length; i++) {
+      const res = event.results[i];
+      const alt = res && res[0];
+      const transcript = ((_c = (_b = alt === null || alt === void 0 ? void 0 : alt.transcript) === null || _b === void 0 ? void 0 : _b.trim) === null || _c === void 0 ? void 0 : _c.call(_b)) || "";
+      const confidence = (_d = alt === null || alt === void 0 ? void 0 : alt.confidence) !== null && _d !== void 0 ? _d : 0;
+      if (!transcript)
+        continue;
+      if (!res.isFinal && options.interimResults === false)
+        continue;
+      if (res.isFinal && confidence < threshold)
+        continue;
+      try {
+        this.hadResultThisSession = true;
+        this.resultCallback(transcript, !!res.isFinal);
+      } catch (_e) {
+        this.error("VoiceProcessor: result callback error");
+      }
+    }
+  }
+  /** Handle session end */
+  handleEnd() {
+    this.log("recognition onend");
+    this.engineActive = false;
+    if (this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking) {
+      if (!this.ttsSpeaking) {
+        this.isListening = false;
+        this.emitStatus("idle");
+      }
+      return;
+    }
+    this.isListening = true;
+    this.scheduleRestart();
+  }
+  /** Handle errors during speech recognition */
+  handleError(event) {
+    const err = event === null || event === void 0 ? void 0 : event.error;
+    this.warn(`Error occurred: ${err !== null && err !== void 0 ? err : "unknown"}`);
+    const fatal = ["not-allowed", "service-not-allowed", "bad-grammar", "language-not-supported"];
+    if (err && fatal.includes(err)) {
+      this.intentionallyStopped = true;
+      this.restartAllowed = false;
+      this.isListening = false;
+      this.emitStatus("error", { error: err });
+      return;
+    }
+    this.scheduleRestart();
+  }
+  safeRestart() {
+    if (!this.recognition)
+      return;
+    if (this.engineActive) {
+      this.log("safeRestart: engine already active, skipping start");
+      return;
+    }
+    const now = Date.now();
+    if (now - this.lastStart < 300) {
+      setTimeout(() => this.safeRestart(), 300);
+      return;
+    }
+    this.lastStart = now;
+    try {
+      this.log("calling recognition.start()");
+      this.recognition.start();
+      this.backoffMs = 250;
+      if (this.isListening && !this.ttsSpeaking) {
+        this.emitStatus("listening");
+      }
+    } catch (_a) {
+      this.error("recognition.start() threw; scheduling restart");
+      this.scheduleRestart();
+    }
+  }
+  scheduleRestart() {
+    if (this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking)
+      return;
+    if (this.engineActive) {
+      this.log("scheduleRestart: engine active, not scheduling");
+      return;
+    }
+    const delay = Math.min(this.backoffMs, 2e3);
+    this.log(`scheduleRestart in ${delay}ms`);
+    if (this.restartTimer) {
+      this.log("scheduleRestart: restart already scheduled");
+      return;
+    }
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      if (this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking)
+        return;
+      this.safeRestart();
+    }, delay);
+    this.backoffMs = Math.min(this.backoffMs * 2, 2e3);
+  }
+  prewarmAudio() {
+    return __awaiter3(this, void 0, void 0, function* () {
+      if (this.prewarmed)
+        return;
+      try {
+        if (typeof navigator === "undefined" || !("mediaDevices" in navigator))
+          return;
+        const md = navigator.mediaDevices;
+        if (!(md === null || md === void 0 ? void 0 : md.getUserMedia))
+          return;
+        this.log("prewarmAudio: requesting mic");
+        const stream = yield md.getUserMedia({ audio: true });
+        for (const track of stream.getTracks())
+          track.stop();
+        this.prewarmed = true;
+        this.log("prewarmAudio: mic ready");
+      } catch (_a) {
+        this.warn("prewarmAudio: failed to get mic");
+      }
+    });
+  }
+  emitStatus(status, details) {
+    if (!this.statusCallback)
+      return;
+    try {
+      this.statusCallback(status, details);
+    } catch (_a) {
+      this.error("VoiceProcessor: status callback error");
+    }
+  }
+};
+
+// dist/libs/core/src/lib/utils/dom-interactions.js
+var GestureHandler = class {
+  constructor() {
+    this.lastTap = 0;
+  }
+  /**
+   * Sets up double-click and double-tap listeners
+   * @param onDoubleClickOrTap Callback to execute when a double-click or double-tap is detected
+   */
+  setupDoubleTapListener(onDoubleClickOrTap) {
+    this.destroy();
+    this.dblClickListener = () => {
+      onDoubleClickOrTap();
+    };
+    document.addEventListener("dblclick", this.dblClickListener);
+    this.touchEndListener = () => {
+      const currentTime = (/* @__PURE__ */ new Date()).getTime();
+      const tapInterval = currentTime - this.lastTap;
+      if (tapInterval < 300 && tapInterval > 0) {
+        onDoubleClickOrTap();
+      }
+      this.lastTap = currentTime;
+    };
+    document.addEventListener("touchend", this.touchEndListener);
+  }
+  destroy() {
+    if (this.dblClickListener) {
+      document.removeEventListener("dblclick", this.dblClickListener);
+    }
+    if (this.touchEndListener) {
+      document.removeEventListener("touchend", this.touchEndListener);
+    }
+    this.dblClickListener = void 0;
+    this.touchEndListener = void 0;
+  }
+};
+function injectStyles() {
+  const existingStyle = document.querySelector("#assistant-styles");
+  if (existingStyle) {
+    console.log("Styles already injected");
+    return;
+  }
+  const style = document.createElement("style");
+  style.id = "assistant-styles";
+  style.innerHTML = `
+    /* Rounded shape with gradient animation */
+    .gradient-indicator {
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      width: 60px;
+      height: 60px;
+      border-radius: 50%;
+      background: linear-gradient(135deg, #ff6ec4, #7873f5, #5e8cff, #6ed0f6);
+      box-shadow: 0 0 15px rgba(0, 0, 0, 0.2);
+      animation: amoeba 5s infinite ease-in-out;
+      z-index: 9999; /* Ensure it's above all other elements */
+    }
+
+    /* Amoeba effect for the borders */
+    @keyframes amoeba {
+      0% {
+        border-radius: 50%;
+      }
+      25% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      50% {
+        border-radius: 60% 40% 40% 60%;
+      }
+      75% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      100% {
+        border-radius: 50%;
+      }
+    }
+  `;
+  document.head.appendChild(style);
+  console.log("Gradient styles injected");
+}
+function addGradientAnimation() {
+  if (document.querySelector("#gradient-indicator")) {
+    return;
+  }
+  const gradientDiv = document.createElement("div");
+  gradientDiv.id = "gradient-indicator";
+  injectStyles();
+  gradientDiv.classList.add("gradient-indicator");
+  document.body.appendChild(gradientDiv);
+  console.log("Gradient indicator added to the DOM");
+}
+function removeGradientAnimation() {
+  const gradientDiv = document.querySelector("#gradient-indicator");
+  if (gradientDiv) {
+    gradientDiv.remove();
+    console.log("Gradient indicator removed from the DOM");
+  }
+}
+
+// dist/libs/core/src/lib/state-manager.js
+var StateManager = class {
+  constructor() {
+    this.state = "idle";
+    this.subscribers = [];
+  }
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+    this.notifySubscribers();
+    console.log("State updated:", state);
+    if (state === "listening") {
+      addGradientAnimation();
+    } else {
+      removeGradientAnimation();
+    }
+  }
+  // eslint-disable-next-line no-unused-vars
+  subscribe(callback) {
+    this.subscribers.push(callback);
+  }
+  notifySubscribers() {
+    this.subscribers.forEach((callback) => callback(this.state));
+  }
+};
+
+// dist/libs/core/src/lib/ui/overlay-manager.js
+import { __awaiter as __awaiter4 } from "tslib";
+var OverlayManager = class {
+  constructor(config) {
+    this.container = null;
+    this.chatWindow = null;
+    this.messagesContainer = null;
+    this.input = null;
+    this.isOpen = false;
+    this.loadingEl = null;
+    this.config = config;
+    this.init();
+  }
+  init() {
+    var _a, _b;
+    if (this.container)
+      return;
+    this.injectOverlayStyles();
+    const existing = document.getElementById("foisit-overlay-container");
+    if (existing && existing instanceof HTMLElement) {
+      this.container = existing;
+      this.chatWindow = existing.querySelector(".foisit-chat");
+      this.messagesContainer = existing.querySelector(".foisit-messages");
+      this.input = existing.querySelector("input.foisit-input");
+      if (((_a = this.config.floatingButton) === null || _a === void 0 ? void 0 : _a.visible) !== false && !existing.querySelector(".foisit-floating-btn")) {
+        this.renderFloatingButton();
+      }
+      if (!this.chatWindow) {
+        this.renderChatWindow();
+      }
+      return;
+    }
+    this.container = document.createElement("div");
+    this.container.id = "foisit-overlay-container";
+    this.container.className = "foisit-overlay-container";
+    document.body.appendChild(this.container);
+    if (((_b = this.config.floatingButton) === null || _b === void 0 ? void 0 : _b.visible) !== false) {
+      this.renderFloatingButton();
+    }
+    this.renderChatWindow();
+  }
+  renderFloatingButton() {
+    var _a, _b, _c, _d, _e, _f;
+    const btn = document.createElement("button");
+    btn.innerHTML = ((_a = this.config.floatingButton) === null || _a === void 0 ? void 0 : _a.customHtml) || "\u{1F399}\uFE0F";
+    const bottom = ((_c = (_b = this.config.floatingButton) === null || _b === void 0 ? void 0 : _b.position) === null || _c === void 0 ? void 0 : _c.bottom) || "20px";
+    const right = ((_e = (_d = this.config.floatingButton) === null || _d === void 0 ? void 0 : _d.position) === null || _e === void 0 ? void 0 : _e.right) || "20px";
+    btn.className = "foisit-floating-btn";
+    btn.style.bottom = bottom;
+    btn.style.right = right;
+    btn.onclick = () => this.toggle();
+    btn.onmouseenter = () => btn.style.transform = "scale(1.05)";
+    btn.onmouseleave = () => btn.style.transform = "scale(1)";
+    (_f = this.container) === null || _f === void 0 ? void 0 : _f.appendChild(btn);
+  }
+  renderChatWindow() {
+    var _a;
+    if (this.chatWindow)
+      return;
+    this.chatWindow = document.createElement("div");
+    this.chatWindow.className = "foisit-chat";
+    const header = document.createElement("div");
+    header.className = "foisit-header";
+    const title = document.createElement("span");
+    title.className = "foisit-title";
+    title.textContent = "Foisit";
+    const closeButton = document.createElement("button");
+    closeButton.type = "button";
+    closeButton.className = "foisit-close";
+    closeButton.setAttribute("aria-label", "Close");
+    closeButton.innerHTML = "&times;";
+    closeButton.addEventListener("click", () => this.toggle());
+    header.appendChild(title);
+    header.appendChild(closeButton);
+    this.messagesContainer = document.createElement("div");
+    this.messagesContainer.className = "foisit-messages";
+    const inputArea = document.createElement("div");
+    inputArea.className = "foisit-input-area";
+    this.input = document.createElement("input");
+    this.input.placeholder = this.config.inputPlaceholder || "Type a command...";
+    this.input.className = "foisit-input";
+    this.input.addEventListener("keydown", (e) => {
+      var _a2;
+      if (e.key === "Enter" && ((_a2 = this.input) === null || _a2 === void 0 ? void 0 : _a2.value.trim())) {
+        const text = this.input.value.trim();
+        this.input.value = "";
+        if (this.onSubmit)
+          this.onSubmit(text);
+      }
+    });
+    inputArea.appendChild(this.input);
+    this.chatWindow.appendChild(header);
+    this.chatWindow.appendChild(this.messagesContainer);
+    this.chatWindow.appendChild(inputArea);
+    (_a = this.container) === null || _a === void 0 ? void 0 : _a.appendChild(this.chatWindow);
+  }
+  registerCallbacks(onSubmit, onClose) {
+    this.onSubmit = onSubmit;
+    this.onClose = onClose;
+  }
+  toggle(onSubmit, onClose) {
+    if (onSubmit)
+      this.onSubmit = onSubmit;
+    if (onClose)
+      this.onClose = onClose;
+    this.isOpen = !this.isOpen;
+    if (this.chatWindow) {
+      if (this.isOpen) {
+        this.chatWindow.style.display = "flex";
+        requestAnimationFrame(() => {
+          if (this.chatWindow) {
+            this.chatWindow.style.opacity = "1";
+            this.chatWindow.style.transform = "translateY(0) scale(1)";
+          }
+        });
+        setTimeout(() => {
+          var _a;
+          return (_a = this.input) === null || _a === void 0 ? void 0 : _a.focus();
+        }, 100);
+      } else {
+        this.chatWindow.style.opacity = "0";
+        this.chatWindow.style.transform = "translateY(20px) scale(0.95)";
+        setTimeout(() => {
+          if (this.chatWindow && !this.isOpen) {
+            this.chatWindow.style.display = "none";
+          }
+        }, 200);
+        if (this.onClose)
+          this.onClose();
+      }
+    }
+  }
+  addMessage(text, type) {
+    if (!this.messagesContainer)
+      return;
+    const msg = document.createElement("div");
+    msg.textContent = text;
+    msg.className = type === "user" ? "foisit-bubble user" : "foisit-bubble system";
+    this.messagesContainer.appendChild(msg);
+    this.scrollToBottom();
+  }
+  addOptions(options) {
+    if (!this.messagesContainer)
+      return;
+    const container = document.createElement("div");
+    container.className = "foisit-options-container";
+    options.forEach((opt) => {
+      const btn = document.createElement("button");
+      btn.textContent = opt.label;
+      btn.className = "foisit-option-chip";
+      btn.setAttribute("type", "button");
+      btn.setAttribute("aria-label", opt.label);
+      const clickPayload = () => {
+        if (opt.commandId) {
+          if (this.onSubmit)
+            this.onSubmit({ commandId: opt.commandId });
+          return;
+        }
+        const value = opt && typeof opt.value === "string" && opt.value.trim() ? opt.value : opt.label;
+        if (this.onSubmit)
+          this.onSubmit(value);
+      };
+      btn.onclick = clickPayload;
+      btn.onkeydown = (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          clickPayload();
+        }
+      };
+      container.appendChild(btn);
+    });
+    this.messagesContainer.appendChild(container);
+    this.scrollToBottom();
+  }
+  addForm(message, fields, onSubmit) {
+    if (!this.messagesContainer)
+      return;
+    this.addMessage(message, "system");
+    const form = document.createElement("form");
+    form.className = "foisit-form";
+    const controls = [];
+    const createLabel = (text, required) => {
+      const label = document.createElement("div");
+      label.className = "foisit-form-label";
+      label.innerHTML = text + (required ? ' <span class="foisit-req-star">*</span>' : "");
+      return label;
+    };
+    const createError = () => {
+      const error = document.createElement("div");
+      error.className = "foisit-form-error";
+      error.style.display = "none";
+      return error;
+    };
+    (fields !== null && fields !== void 0 ? fields : []).forEach((field) => {
+      const wrapper = document.createElement("div");
+      wrapper.className = "foisit-form-group";
+      const labelText = field.description || field.name;
+      wrapper.appendChild(createLabel(labelText, field.required));
+      let inputEl;
+      if (field.type === "select") {
+        const select = document.createElement("select");
+        select.className = "foisit-form-input";
+        const placeholderOpt = document.createElement("option");
+        placeholderOpt.value = "";
+        placeholderOpt.textContent = "Select...";
+        select.appendChild(placeholderOpt);
+        const populate = (options) => {
+          (options !== null && options !== void 0 ? options : []).forEach((opt) => {
+            var _a, _b, _c, _d;
+            const o = document.createElement("option");
+            o.value = String((_b = (_a = opt.value) !== null && _a !== void 0 ? _a : opt.label) !== null && _b !== void 0 ? _b : "");
+            o.textContent = String((_d = (_c = opt.label) !== null && _c !== void 0 ? _c : opt.value) !== null && _d !== void 0 ? _d : "");
+            select.appendChild(o);
+          });
+        };
+        if (Array.isArray(field.options) && field.options.length) {
+          populate(field.options);
+        } else if (typeof field.getOptions === "function") {
+          const getOptions = field.getOptions;
+          const loadingOpt = document.createElement("option");
+          loadingOpt.value = "";
+          loadingOpt.textContent = "Loading...";
+          select.appendChild(loadingOpt);
+          Promise.resolve().then(() => getOptions()).then((opts) => {
+            while (select.options.length > 1)
+              select.remove(1);
+            populate(opts);
+          }).catch(() => {
+            while (select.options.length > 1)
+              select.remove(1);
+            const errOpt = document.createElement("option");
+            errOpt.value = "";
+            errOpt.textContent = "Error loading options";
+            select.appendChild(errOpt);
+          });
+        }
+        if (field.defaultValue != null) {
+          select.value = String(field.defaultValue);
+        }
+        inputEl = select;
+      } else if (field.type === "file") {
+        const ffield = field;
+        const input = document.createElement("input");
+        input.className = "foisit-form-input";
+        input.type = "file";
+        if (ffield.accept && Array.isArray(ffield.accept)) {
+          input.accept = ffield.accept.join(",");
+        }
+        if (ffield.multiple)
+          input.multiple = true;
+        if (ffield.capture) {
+          if (ffield.capture === true)
+            input.setAttribute("capture", "");
+          else
+            input.setAttribute("capture", String(ffield.capture));
+        }
+        input.addEventListener("change", () => __awaiter4(this, void 0, void 0, function* () {
+          var _a, _b, _c;
+          const files = Array.from(input.files || []);
+          const errEl = errorEl;
+          errEl.style.display = "none";
+          errEl.textContent = "";
+          if (files.length === 0)
+            return;
+          const maxFiles = (_a = ffield.maxFiles) !== null && _a !== void 0 ? _a : ffield.multiple ? 10 : 1;
+          if (files.length > maxFiles) {
+            errEl.textContent = `Please select at most ${maxFiles} file(s).`;
+            errEl.style.display = "block";
             return;
+          }
+          const maxSize = (_b = ffield.maxSizeBytes) !== null && _b !== void 0 ? _b : Infinity;
+          const total = files.reduce((s, f) => s + f.size, 0);
+          if (files.some((f) => f.size > maxSize)) {
+            errEl.textContent = `One or more files exceed the maximum size of ${Math.round(maxSize / 1024)} KB.`;
+            errEl.style.display = "block";
+            return;
+          }
+          const maxTotal = (_c = ffield.maxTotalBytes) !== null && _c !== void 0 ? _c : Infinity;
+          if (total > maxTotal) {
+            errEl.textContent = `Total selected files exceed the maximum of ${Math.round(maxTotal / 1024)} KB.`;
+            errEl.style.display = "block";
+            return;
+          }
+          if (ffield.accept && Array.isArray(ffield.accept)) {
+            const accepts = ffield.accept;
+            const ok = files.every((file) => {
+              if (!file.type)
+                return true;
+              return accepts.some((a) => a.startsWith(".") ? file.name.toLowerCase().endsWith(a.toLowerCase()) : file.type === a || file.type.startsWith(a.split("/")[0] + "/"));
+            });
+            if (!ok) {
+              errEl.textContent = "One or more files have an unsupported type.";
+              errEl.style.display = "block";
+              return;
+            }
+          }
+        }));
+        inputEl = input;
+      } else {
+        const input = document.createElement("input");
+        input.className = "foisit-form-input";
+        if (field.type === "string") {
+          input.placeholder = field.placeholder || "Type here...";
+        }
+        if (field.type === "number") {
+          input.type = "number";
+          if (typeof field.min === "number")
+            input.min = String(field.min);
+          if (typeof field.max === "number")
+            input.max = String(field.max);
+          if (typeof field.step === "number")
+            input.step = String(field.step);
+          if (field.defaultValue != null)
+            input.value = String(field.defaultValue);
+        } else if (field.type === "date") {
+          input.type = "date";
+          if (typeof field.min === "string")
+            input.min = field.min;
+          if (typeof field.max === "string")
+            input.max = field.max;
+          if (field.defaultValue != null)
+            input.value = String(field.defaultValue);
+        } else {
+          input.type = "text";
+          if (field.defaultValue != null)
+            input.value = String(field.defaultValue);
         }
-        if (response.type === 'form' && response.fields) {
-            this.overlayManager.addForm(response.message, response.fields, async (data) => {
-                this.overlayManager.showLoading();
-                let nextReponse;
-                try {
-                    nextReponse = await this.commandHandler.executeCommand(data);
+        inputEl = input;
+      }
+      const errorEl = createError();
+      wrapper.appendChild(inputEl);
+      wrapper.appendChild(errorEl);
+      controls.push({
+        name: field.name,
+        type: field.type,
+        el: inputEl,
+        required: field.required
+      });
+      form.appendChild(wrapper);
+    });
+    const actions = document.createElement("div");
+    actions.className = "foisit-form-actions";
+    const submitBtn = document.createElement("button");
+    submitBtn.type = "submit";
+    submitBtn.textContent = "Submit";
+    submitBtn.className = "foisit-option-chip";
+    submitBtn.style.fontWeight = "600";
+    actions.appendChild(submitBtn);
+    form.appendChild(actions);
+    form.onsubmit = (e) => __awaiter4(this, void 0, void 0, function* () {
+      var _a, _b;
+      e.preventDefault();
+      const data = {};
+      let hasError = false;
+      form.querySelectorAll(".foisit-form-error").forEach((el) => {
+        el.style.display = "none";
+        el.textContent = "";
+      });
+      form.querySelectorAll(".foisit-form-input").forEach((el) => {
+        el.classList.remove("foisit-error-border");
+      });
+      for (const c of controls) {
+        if (c.type === "file") {
+          const fileWrapper = c.el.parentElement;
+          const fileErrorEl = fileWrapper === null || fileWrapper === void 0 ? void 0 : fileWrapper.querySelector(".foisit-form-error");
+          const input = c.el;
+          const files = Array.from(input.files || []);
+          if (c.required && files.length === 0) {
+            hasError = true;
+            input.classList.add("foisit-error-border");
+            if (fileErrorEl) {
+              fileErrorEl.textContent = "This file is required";
+              fileErrorEl.style.display = "block";
+            }
+            continue;
+          }
+          if (files.length === 0)
+            continue;
+          const fieldDef = (fields !== null && fields !== void 0 ? fields : []).find((f) => f.name === c.name);
+          const delivery = (_a = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.delivery) !== null && _a !== void 0 ? _a : "file";
+          if ((fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.maxWidth) || (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.maxHeight)) {
+            try {
+              const dims = yield this.getImageDimensions(files[0]);
+              if (fieldDef.maxWidth && dims.width > fieldDef.maxWidth) {
+                hasError = true;
+                if (fileErrorEl) {
+                  fileErrorEl.textContent = `Image width must be \u2264 ${fieldDef.maxWidth}px`;
+                  fileErrorEl.style.display = "block";
                 }
-                finally {
-                    this.overlayManager.hideLoading();
+                continue;
+              }
+              if (fieldDef.maxHeight && dims.height > fieldDef.maxHeight) {
+                hasError = true;
+                if (fileErrorEl) {
+                  fileErrorEl.textContent = `Image height must be \u2264 ${fieldDef.maxHeight}px`;
+                  fileErrorEl.style.display = "block";
                 }
-                this.processResponse(nextReponse);
-            });
-            return;
-        }
-        if ((response.type === 'ambiguous' || response.type === 'confirm') && response.options) {
-            if (response.message) {
-                this.overlayManager.addMessage(response.message, 'system');
+                continue;
+              }
+            } catch (_c) {
             }
-            this.overlayManager.addOptions(response.options);
-            return;
+          }
+          if (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.maxDurationSec) {
+            try {
+              const dur = yield this.getMediaDuration(files[0]);
+              if (dur && dur > fieldDef.maxDurationSec) {
+                hasError = true;
+                if (fileErrorEl) {
+                  fileErrorEl.textContent = `Media duration must be \u2264 ${fieldDef.maxDurationSec}s`;
+                  fileErrorEl.style.display = "block";
+                }
+                continue;
+              }
+            } catch (_d) {
+            }
+          }
+          if (delivery === "file") {
+            data[c.name] = (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.multiple) ? files : files[0];
+          } else if (delivery === "base64") {
+            try {
+              const encoded = yield Promise.all(files.map((file) => this.readFileAsDataURL(file)));
+              data[c.name] = (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.multiple) ? encoded : encoded[0];
+            } catch (_e) {
+              hasError = true;
+              if (fileErrorEl) {
+                fileErrorEl.textContent = "Failed to encode file(s) to base64.";
+                fileErrorEl.style.display = "block";
+              }
+              continue;
+            }
+          }
+          continue;
         }
-        if (response.message) {
-            this.overlayManager.addMessage(response.message, 'system');
+        const val = ((_b = c.el.value) !== null && _b !== void 0 ? _b : "").toString().trim();
+        const valueWrapper = c.el.parentElement;
+        const fieldErrorEl = valueWrapper === null || valueWrapper === void 0 ? void 0 : valueWrapper.querySelector(".foisit-form-error");
+        if (c.required && (val == null || val === "")) {
+          hasError = true;
+          c.el.classList.add("foisit-error-border");
+          if (fieldErrorEl) {
+            fieldErrorEl.textContent = "This field is required";
+            fieldErrorEl.style.display = "block";
+          }
+          continue;
         }
+        if (val === "")
+          continue;
+        if (c.type === "number") {
+          const n = Number(val);
+          if (!Number.isNaN(n))
+            data[c.name] = n;
+        } else {
+          data[c.name] = val;
+        }
+      }
+      if (hasError) {
+        form.classList.add("foisit-shake");
+        setTimeout(() => form.classList.remove("foisit-shake"), 400);
+        return;
+      }
+      submitBtn.disabled = true;
+      submitBtn.style.opacity = "0.6";
+      controls.forEach((c) => {
+        c.el.disabled = true;
+      });
+      onSubmit(data);
+    });
+    this.messagesContainer.appendChild(form);
+    this.scrollToBottom();
+  }
+  showLoading() {
+    if (!this.messagesContainer)
+      return;
+    if (this.loadingEl)
+      return;
+    this.loadingEl = document.createElement("div");
+    this.loadingEl.className = "foisit-loading-dots foisit-bubble system";
+    for (let i = 0; i < 3; i++) {
+      const dot = document.createElement("div");
+      dot.className = "foisit-dot";
+      dot.style.animation = `foisitPulse 1.4s infinite ease-in-out ${i * 0.2}s`;
+      this.loadingEl.appendChild(dot);
+    }
+    this.messagesContainer.appendChild(this.loadingEl);
+    this.scrollToBottom();
+  }
+  hideLoading() {
+    var _a;
+    (_a = this.loadingEl) === null || _a === void 0 ? void 0 : _a.remove();
+    this.loadingEl = null;
+  }
+  scrollToBottom() {
+    if (this.messagesContainer) {
+      this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
     }
-    /** Add a command dynamically (supports string or rich object) */
-    addCommand(commandOrObj, action) {
-        if (typeof commandOrObj === 'string') {
-            console.log(`AssistantService: Adding command "${commandOrObj}".`);
+  }
+  destroy() {
+    var _a;
+    (_a = this.container) === null || _a === void 0 ? void 0 : _a.remove();
+    this.container = null;
+    this.chatWindow = null;
+    this.messagesContainer = null;
+    this.input = null;
+    this.isOpen = false;
+  }
+  readFileAsDataURL(file) {
+    return new Promise((resolve, reject) => {
+      const fr = new FileReader();
+      fr.onerror = () => reject(new Error("Failed to read file"));
+      fr.onload = () => resolve(String(fr.result));
+      fr.readAsDataURL(file);
+    });
+  }
+  getImageDimensions(file) {
+    return new Promise((resolve) => {
+      try {
+        const url = URL.createObjectURL(file);
+        const img = new Image();
+        img.onload = () => {
+          const dims = { width: img.naturalWidth || img.width, height: img.naturalHeight || img.height };
+          URL.revokeObjectURL(url);
+          resolve(dims);
+        };
+        img.onerror = () => {
+          URL.revokeObjectURL(url);
+          resolve({ width: 0, height: 0 });
+        };
+        img.src = url;
+      } catch (_a) {
+        resolve({ width: 0, height: 0 });
+      }
+    });
+  }
+  getMediaDuration(file) {
+    return new Promise((resolve) => {
+      try {
+        const url = URL.createObjectURL(file);
+        const el = file.type.startsWith("audio") ? document.createElement("audio") : document.createElement("video");
+        let settled = false;
+        const timeout = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            URL.revokeObjectURL(url);
+            resolve(0);
+          }
+        }, 5e3);
+        el.preload = "metadata";
+        el.onloadedmetadata = () => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timeout);
+          const mediaEl = el;
+          const d = mediaEl.duration || 0;
+          URL.revokeObjectURL(url);
+          resolve(d);
+        };
+        el.onerror = () => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timeout);
+          URL.revokeObjectURL(url);
+          resolve(0);
+        };
+        el.src = url;
+      } catch (_a) {
+        resolve(0);
+      }
+    });
+  }
+  injectOverlayStyles() {
+    if (document.getElementById("foisit-overlay-styles"))
+      return;
+    const style = document.createElement("style");
+    style.id = "foisit-overlay-styles";
+    style.textContent = `
+      :root {
+        /* LIGHT MODE (Default) - Smoother gradient */
+        /* Changed: Softer, right-focused radial highlight to avoid a heavy white bottom */
+        --foisit-bg: radial-gradient(ellipse at 75% 30%, rgba(255, 255, 255, 0.18), rgba(255, 255, 255, 0.03));
+        --foisit-border: 1px solid rgba(255, 255, 255, 0.25);
+        --foisit-shadow: 0 12px 40px rgba(0, 0, 0, 0.15);
+        --foisit-text: #333;
+
+        /* Input */
+        --foisit-input-color: #333;
+        --foisit-input-placeholder: rgba(60, 60, 67, 0.6);
+
+        /* Bubbles */
+        --foisit-bubble-user-bg: rgba(0, 0, 0, 0.04);
+        --foisit-bubble-user-text: #333;
+
+        --foisit-bubble-sys-bg: rgba(255, 255, 255, 0.45);
+        --foisit-bubble-sys-text: #333;
+
+        /* Form Colors */
+        --foisit-req-star: #ef4444; /* Red asterisk */
+        --foisit-error-text: #dc2626;
+        --foisit-error-border: #fca5a5;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :root {
+          /* DARK MODE */
+          --foisit-bg: linear-gradient(135deg, rgba(40, 40, 40, 0.65), rgba(40, 40, 40, 0.25));
+          --foisit-border: 1px solid rgba(255, 255, 255, 0.1);
+          --foisit-shadow: 0 16px 48px rgba(0, 0, 0, 0.5);
+          --foisit-text: #fff;
+
+          /* Input */
+          --foisit-input-color: white;
+          --foisit-input-placeholder: rgba(235, 235, 245, 0.5);
+
+          /* Bubbles */
+          --foisit-bubble-user-bg: rgba(255, 255, 255, 0.1);
+          --foisit-bubble-user-text: white;
+
+          --foisit-bubble-sys-bg: rgba(255, 255, 255, 0.05);
+          --foisit-bubble-sys-text: rgba(255, 255, 255, 0.9);
+
+          /* Form Colors */
+          --foisit-req-star: #f87171;
+          --foisit-error-text: #fca5a5;
+          --foisit-error-border: #f87171;
         }
-        else {
-            console.log(`AssistantService: Adding rich command "${commandOrObj.command}".`);
+      }
+
+      @keyframes foisitPulse {
+        0%, 100% { transform: scale(0.8); opacity: 0.5; }
+        50% { transform: scale(1.2); opacity: 1; }
+      }
+
+      @keyframes foisitShake {
+        0%, 100% { transform: translateX(0); }
+        25% { transform: translateX(-4px); }
+        75% { transform: translateX(4px); }
+      }
+      .foisit-shake { animation: foisitShake 0.4s ease-in-out; }
+
+      /* Container */
+      .foisit-overlay-container {
+        position: fixed;
+        inset: 0;
+        z-index: 2147483647;
+        pointer-events: none;
+        display: flex;
+        flex-direction: column;
+        justify-content: flex-end;
+        align-items: flex-end;
+        padding: 20px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      }
+
+      .foisit-overlay-container * {
+        box-sizing: border-box;
+      }
+
+      /* Chat Window - Dynamic Height */
+      .foisit-chat {
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        width: min(420px, 92vw);
+
+        /* FIX: Auto height to prevent empty space */
+        height: auto;
+        min-height: 120px;
+        max-height: 80vh;
+
+        background: var(--foisit-bg);
+        border: var(--foisit-border);
+        box-shadow: var(--foisit-shadow);
+
+        backdrop-filter: blur(20px);
+        -webkit-backdrop-filter: blur(20px);
+
+        border-radius: 18px;
+        display: none;
+        flex-direction: column;
+        overflow: hidden;
+        pointer-events: auto;
+        transform-origin: top right;
+        transition: opacity 0.2s, transform 0.2s cubic-bezier(0.2, 0.9, 0.2, 1);
+      }
+
+      .foisit-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 12px 16px;
+        font-weight: 600;
+        font-size: 14px;
+        color: var(--foisit-text);
+        border-bottom: 1px solid rgba(127,127,127,0.08); /* Subtle separator */
+      }
+
+      .foisit-close {
+        background: transparent;
+        border: none;
+        color: var(--foisit-text);
+        opacity: 0.5;
+        font-size: 24px;
+        line-height: 1;
+        cursor: pointer;
+        padding: 0;
+        width: 28px;
+        height: 28px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: opacity 0.2s;
+      }
+      .foisit-close:hover { opacity: 1; }
+
+      /* Message Area */
+      .foisit-messages {
+        flex: 1;
+        overflow-y: auto;
+        padding: 16px;
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+        /* Ensure it doesn't get too tall initially */
+        min-height: 60px;
+      }
+
+      /* Make sure empty state isn't huge */
+      .foisit-messages:empty {
+        display: none;
+      }
+
+      /* Only show messages container if it has children */
+      .foisit-messages:not(:empty) {
+        display: flex;
+      }
+
+      /* Bubbles */
+      .foisit-bubble {
+        max-width: 90%;
+        padding: 8px 14px;
+        border-radius: 14px;
+        font-size: 14px;
+        line-height: 1.4;
+        word-wrap: break-word;
+      }
+
+      .foisit-bubble.user {
+        align-self: flex-end;
+        background: var(--foisit-bubble-user-bg);
+        color: var(--foisit-bubble-user-text);
+        border-bottom-right-radius: 4px;
+      }
+
+      .foisit-bubble.system {
+        align-self: flex-start;
+        background: var(--foisit-bubble-sys-bg);
+        color: var(--foisit-bubble-sys-text);
+        border-bottom-left-radius: 4px;
+        border: 1px solid rgba(255,255,255,0.1);
+      }
+
+      /* Input Area */
+      .foisit-input-area {
+        padding: 0;
+        width: 100%;
+        border-top: 1px solid rgba(127,127,127,0.08);
+      }
+
+      .foisit-input {
+        width: 100%;
+        background: transparent;
+        border: none;
+        font-size: 16px;
+        color: var(--foisit-input-color);
+        padding: 16px 20px;
+        outline: none;
+        text-align: left;
+      }
+
+      .foisit-input::placeholder {
+        color: var(--foisit-input-placeholder);
+        font-weight: 400;
+      }
+
+      /* Options & Buttons */
+      .foisit-options-container {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-left: 2px;
+        margin-top: 4px;
+      }
+
+      .foisit-option-chip {
+        padding: 6px 14px;
+        background: var(--foisit-bubble-sys-bg);
+        border: 1px solid rgba(127,127,127,0.1);
+        border-radius: 20px;
+        font-size: 13px;
+        color: var(--foisit-text);
+        cursor: pointer;
+        transition: all 0.2s;
+        font-weight: 500;
+      }
+      .foisit-option-chip:hover {
+        background: rgba(127,127,127,0.15);
+      }
+
+      /* Form Styling */
+      .foisit-form {
+        background: var(--foisit-bubble-sys-bg);
+        padding: 16px;
+        border-radius: 14px;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        width: 100%;
+        border: 1px solid rgba(127,127,127,0.1);
+      }
+
+      .foisit-form-label {
+        font-size: 12px;
+        font-weight: 600;
+        color: var(--foisit-text);
+        opacity: 0.9;
+        margin-bottom: 2px;
+      }
+
+      .foisit-req-star {
+        color: var(--foisit-req-star);
+        font-weight: bold;
+      }
+
+      .foisit-form-input {
+        width: 100%;
+        padding: 10px;
+        border-radius: 8px;
+        border: 1px solid rgba(127,127,127,0.2);
+        background: rgba(255,255,255,0.05); /* Very subtle fill */
+        color: var(--foisit-text);
+        font-size: 14px;
+        outline: none;
+        transition: border 0.2s;
+      }
+      .foisit-form-input:focus {
+        border-color: var(--foisit-text);
+        background: rgba(255,255,255,0.1);
+      }
+
+      .foisit-error-border {
+        border-color: var(--foisit-error-border) !important;
+      }
+
+      .foisit-form-error {
+        font-size: 11px;
+        color: var(--foisit-error-text);
+        margin-top: 4px;
+      }
+
+      /* Loading */
+      .foisit-loading-dots {
+        display: inline-flex;
+        gap: 4px;
+        padding: 10px 14px;
+        align-self: flex-start;
+      }
+      .foisit-dot {
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        background: var(--foisit-text);
+        opacity: 0.4;
+      }
+
+      /* Floating Button */
+      .foisit-floating-btn {
+        position: absolute;
+        width: 56px;
+        height: 56px;
+        border-radius: 50%;
+        border: 1px solid rgba(255,255,255,0.2);
+        background: var(--foisit-bg);
+        color: var(--foisit-text);
+        backdrop-filter: blur(10px);
+        -webkit-backdrop-filter: blur(10px);
+        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        cursor: pointer;
+        pointer-events: auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 24px;
+        z-index: 100000;
+        transition: transform 0.2s;
+      }
+      .foisit-floating-btn:hover { transform: scale(1.05); }
+    `;
+    document.head.appendChild(style);
+  }
+};
+
+// dist/libs/angular-wrapper/fesm2022/foisit-angular-wrapper.mjs
+var AngularWrapperComponent = class _AngularWrapperComponent {
+  static \u0275fac = i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: _AngularWrapperComponent, deps: [], target: i0.\u0275\u0275FactoryTarget.Component });
+  static \u0275cmp = i0.\u0275\u0275ngDeclareComponent({ minVersion: "14.0.0", version: "19.0.7", type: _AngularWrapperComponent, isStandalone: true, selector: "lib-angular-wrapper", ngImport: i0, template: "<p>AngularWrapper works!</p>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+};
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AngularWrapperComponent, decorators: [{
+  type: Component,
+  args: [{ selector: "lib-angular-wrapper", imports: [CommonModule], template: "<p>AngularWrapper works!</p>\n" }]
+}] });
+var AssistantService = class _AssistantService {
+  config;
+  commandHandler;
+  fallbackHandler;
+  voiceProcessor;
+  textToSpeech;
+  stateManager;
+  lastProcessedInput = "";
+  processingLock = false;
+  isActivated = false;
+  // Tracks activation status
+  gestureHandler;
+  overlayManager;
+  defaultIntroMessage = "How can I help you?";
+  constructor(config) {
+    this.config = config;
+    this.commandHandler = new CommandHandler({
+      enableSmartIntent: this.config.enableSmartIntent !== false,
+      intentEndpoint: this.config.intentEndpoint
+    });
+    this.fallbackHandler = new FallbackHandler();
+    this.voiceProcessor = new VoiceProcessor();
+    this.textToSpeech = new TextToSpeech();
+    this.stateManager = new StateManager();
+    this.gestureHandler = new GestureHandler();
+    this.overlayManager = new OverlayManager({
+      floatingButton: this.config.floatingButton,
+      inputPlaceholder: this.config.inputPlaceholder
+    });
+    this.config.commands.forEach((cmd) => this.commandHandler.addCommand(cmd));
+    if (this.config.fallbackResponse) {
+      this.fallbackHandler.setFallbackMessage(this.config.fallbackResponse);
+    }
+    this.gestureHandler.setupDoubleTapListener(() => this.toggle());
+    this.overlayManager.registerCallbacks(async (input) => {
+      if (typeof input === "string") {
+        this.overlayManager.addMessage(input, "user");
+      } else if (input && typeof input === "object") {
+        const label = this.extractUserLabel(input);
+        if (label) {
+          this.overlayManager.addMessage(label, "user");
         }
-        this.commandHandler.addCommand(commandOrObj, action);
+      }
+      await this.handleCommand(input);
+    }, () => console.log("AssistantService: Overlay closed."));
+  }
+  /** Start listening for activation and commands */
+  startListening() {
+    console.log("AssistantService: Voice is disabled; startListening() is a no-op.");
+    return;
+  }
+  /** Stop listening for voice input */
+  stopListening() {
+    console.log("AssistantService: Voice is disabled; stopListening() is a no-op.");
+    this.isActivated = false;
+  }
+  /** Reset activation state so the next activation flow can occur. */
+  reactivate() {
+    console.log("AssistantService: Reactivating assistant...");
+    this.isActivated = false;
+    try {
+      this.startListening();
+    } catch {
     }
-    /** Remove a command dynamically */
-    removeCommand(command) {
-        console.log(`AssistantService: Removing command "${command}".`);
-        this.commandHandler.removeCommand(command);
+  }
+  /** Process activation command */
+  async processActivation(transcript) {
+    const activationCmd = this.config.activationCommand?.toLowerCase();
+    if (!activationCmd)
+      return;
+    if (transcript === activationCmd) {
+      console.log("AssistantService: Activation matched.");
+      this.isActivated = true;
+      this.textToSpeech.speak(this.config.introMessage || this.defaultIntroMessage);
+    } else {
+      console.log("AssistantService: Activation command not recognized.");
     }
-    /** Get all registered commands */
-    getCommands() {
-        return this.commandHandler.getCommands();
+  }
+  /** Handle recognized commands */
+  async handleCommand(input) {
+    this.overlayManager.showLoading();
+    let response;
+    try {
+      response = await this.commandHandler.executeCommand(input);
+    } finally {
+      this.overlayManager.hideLoading();
     }
-    /** Toggle the assistant overlay */
-    toggle(onSubmit, onClose) {
-        console.log('AssistantService: Toggling overlay...');
-        this.overlayManager.toggle(async (input) => {
-            if (typeof input === 'string') {
-                this.overlayManager.addMessage(input, 'user');
-            }
-            else if (input && typeof input === 'object') {
-                const label = this.extractUserLabel(input);
-                if (label) {
-                    this.overlayManager.addMessage(label, 'user');
-                }
-            }
-            if (onSubmit)
-                onSubmit(input);
-            await this.handleCommand(input);
-        }, () => {
-            console.log('AssistantService: Overlay closed.');
-            if (onClose)
-                onClose();
-        });
+    const originalText = typeof input === "string" ? input : void 0;
+    this.processResponse(response, originalText);
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.voiceProcessor.stopListening();
+    this.gestureHandler.destroy();
+    this.overlayManager.destroy();
+  }
+  /** Unified response processing */
+  processResponse(response, originalText) {
+    if (response.type === "error" && originalText) {
+      this.fallbackHandler.handleFallback(originalText);
+      this.overlayManager.addMessage(this.fallbackHandler.getFallbackMessage(), "system");
+      return;
     }
-    extractUserLabel(payload) {
-        const label = payload['label'];
-        if (typeof label === 'string' && label.trim()) {
-            return label.trim();
+    if (response.type === "form" && response.fields) {
+      this.overlayManager.addForm(response.message, response.fields, async (data) => {
+        this.overlayManager.showLoading();
+        let nextReponse;
+        try {
+          nextReponse = await this.commandHandler.executeCommand(data);
+        } finally {
+          this.overlayManager.hideLoading();
         }
-        const commandId = payload['commandId'];
-        if (typeof commandId === 'string' && commandId.trim()) {
-            return commandId.trim();
+        this.processResponse(nextReponse);
+      });
+      return;
+    }
+    if ((response.type === "ambiguous" || response.type === "confirm") && response.options) {
+      if (response.message) {
+        this.overlayManager.addMessage(response.message, "system");
+      }
+      this.overlayManager.addOptions(response.options);
+      return;
+    }
+    if (response.message) {
+      this.overlayManager.addMessage(response.message, "system");
+    }
+  }
+  /** Add a command dynamically (supports string or rich object) */
+  addCommand(commandOrObj, action) {
+    if (typeof commandOrObj === "string") {
+      console.log(`AssistantService: Adding command "${commandOrObj}".`);
+    } else {
+      console.log(`AssistantService: Adding rich command "${commandOrObj.command}".`);
+    }
+    this.commandHandler.addCommand(commandOrObj, action);
+  }
+  /** Remove a command dynamically */
+  removeCommand(command) {
+    console.log(`AssistantService: Removing command "${command}".`);
+    this.commandHandler.removeCommand(command);
+  }
+  /** Get all registered commands */
+  getCommands() {
+    return this.commandHandler.getCommands();
+  }
+  /** Toggle the assistant overlay */
+  toggle(onSubmit, onClose) {
+    console.log("AssistantService: Toggling overlay...");
+    this.overlayManager.toggle(async (input) => {
+      if (typeof input === "string") {
+        this.overlayManager.addMessage(input, "user");
+      } else if (input && typeof input === "object") {
+        const label = this.extractUserLabel(input);
+        if (label) {
+          this.overlayManager.addMessage(label, "user");
         }
-        return null;
+      }
+      if (onSubmit)
+        onSubmit(input);
+      await this.handleCommand(input);
+    }, () => {
+      console.log("AssistantService: Overlay closed.");
+      if (onClose)
+        onClose();
+    });
+  }
+  extractUserLabel(payload) {
+    const label = payload["label"];
+    if (typeof label === "string" && label.trim()) {
+      return label.trim();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantService, deps: [{ token: 'ASSISTANT_CONFIG' }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['ASSISTANT_CONFIG']
-                }] }] });
-
-class AssistantModule {
-    static forRoot(config) {
-        return {
-            ngModule: AssistantModule,
-            providers: [
-                { provide: 'ASSISTANT_CONFIG', useValue: config },
-                AssistantService,
-            ],
-        };
+    const commandId = payload["commandId"];
+    if (typeof commandId === "string" && commandId.trim()) {
+      return commandId.trim();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.7", ngImport: i0, type: AssistantModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantModule });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantModule, decorators: [{
-            type: NgModule,
-            args: [{}]
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AngularWrapperComponent, AssistantModule, AssistantService };
+    return null;
+  }
+  static \u0275fac = i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: _AssistantService, deps: [{ token: "ASSISTANT_CONFIG" }], target: i0.\u0275\u0275FactoryTarget.Injectable });
+  static \u0275prov = i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: _AssistantService, providedIn: "root" });
+};
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantService, decorators: [{
+  type: Injectable,
+  args: [{
+    providedIn: "root"
+  }]
+}], ctorParameters: () => [{ type: void 0, decorators: [{
+  type: Inject,
+  args: ["ASSISTANT_CONFIG"]
+}] }] });
+var AssistantModule = class _AssistantModule {
+  static forRoot(config) {
+    return {
+      ngModule: _AssistantModule,
+      providers: [
+        { provide: "ASSISTANT_CONFIG", useValue: config },
+        AssistantService
+      ]
+    };
+  }
+  static \u0275fac = i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: _AssistantModule, deps: [], target: i0.\u0275\u0275FactoryTarget.NgModule });
+  static \u0275mod = i0.\u0275\u0275ngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.7", ngImport: i0, type: _AssistantModule });
+  static \u0275inj = i0.\u0275\u0275ngDeclareInjector({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: _AssistantModule });
+};
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AssistantModule, decorators: [{
+  type: NgModule,
+  args: [{}]
+}] });
+export {
+  AngularWrapperComponent,
+  AssistantModule,
+  AssistantService
+};
 //# sourceMappingURL=foisit-angular-wrapper.mjs.map