voicepilot-llm-engine 0.1.0

package/dist/actions/index.d.ts

@@ -0,0 +1,36 @@
+import { Intent, IntentResult } from '../intent/types.js';
+export interface ActionResult {
+    success: boolean;
+    message: string;
+    data?: any;
+}
+export interface ActionContext {
+    pageTitle?: string;
+    availableLinks?: {
+        text: string;
+        href: string;
+    }[];
+    forms?: any[];
+}
+export declare abstract class ActionHandler {
+    abstract canHandle(intent: Intent): boolean;
+    abstract execute(intentResult: IntentResult, context: ActionContext): Promise<ActionResult>;
+}
+export declare class NavigateActionHandler extends ActionHandler {
+    canHandle(intent: Intent): boolean;
+    execute(intentResult: IntentResult, context: ActionContext): Promise<ActionResult>;
+}
+export declare class FormFillActionHandler extends ActionHandler {
+    canHandle(intent: Intent): boolean;
+    execute(intentResult: IntentResult, context: ActionContext): Promise<ActionResult>;
+}
+export declare class ReadPageActionHandler extends ActionHandler {
+    canHandle(intent: Intent): boolean;
+    execute(intentResult: IntentResult, context: ActionContext): Promise<ActionResult>;
+}
+export declare class ActionRouter {
+    private handlers;
+    constructor();
+    route(intentResult: IntentResult, context: ActionContext): Promise<ActionResult>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE1D,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAClD,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;CACf;AAED,8BAAsB,aAAa;IACjC,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAC3C,QAAQ,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAC5F;AAED,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,OAAO,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA4BzF;AAED,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,OAAO,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAiBzF;AAED,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,OAAO,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAOzF;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAkB;;IAU5B,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAYvF"}

package/dist/actions/index.js

@@ -0,0 +1,82 @@
+import { Intent } from '../intent/types.js';
+export class ActionHandler {
+}
+export class NavigateActionHandler extends ActionHandler {
+    canHandle(intent) {
+        return intent === Intent.NAVIGATE;
+    }
+    async execute(intentResult, context) {
+        const target = intentResult.entities?.target;
+        if (!target || !context.availableLinks) {
+            return {
+                success: false,
+                message: 'Could not determine navigation target',
+            };
+        }
+        const link = context.availableLinks.find(l => l.text.toLowerCase().includes(target.toLowerCase()) ||
+            l.href.toLowerCase().includes(target.toLowerCase()));
+        if (link) {
+            return {
+                success: true,
+                message: `Navigating to ${link.text}`,
+                data: { href: link.href, text: link.text },
+            };
+        }
+        return {
+            success: false,
+            message: `Could not find link matching "${target}"`,
+        };
+    }
+}
+export class FormFillActionHandler extends ActionHandler {
+    canHandle(intent) {
+        return intent === Intent.FORM_FILL;
+    }
+    async execute(intentResult, context) {
+        const fieldName = intentResult.entities?.fieldName;
+        const fieldValue = intentResult.entities?.fieldValue;
+        if (!fieldName || !fieldValue) {
+            return {
+                success: false,
+                message: 'Could not extract field name or value',
+            };
+        }
+        return {
+            success: true,
+            message: `Filling ${fieldName} with ${fieldValue}`,
+            data: { fieldName, fieldValue },
+        };
+    }
+}
+export class ReadPageActionHandler extends ActionHandler {
+    canHandle(intent) {
+        return intent === Intent.READ_PAGE;
+    }
+    async execute(intentResult, context) {
+        return {
+            success: true,
+            message: 'Reading page content',
+            data: { action: 'read', section: intentResult.entities?.section },
+        };
+    }
+}
+export class ActionRouter {
+    handlers;
+    constructor() {
+        this.handlers = [
+            new NavigateActionHandler(),
+            new FormFillActionHandler(),
+            new ReadPageActionHandler(),
+        ];
+    }
+    async route(intentResult, context) {
+        const handler = this.handlers.find(h => h.canHandle(intentResult.intent));
+        if (!handler) {
+            return {
+                success: false,
+                message: `No handler found for intent: ${intentResult.intent}`,
+            };
+        }
+        return handler.execute(intentResult, context);
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+export interface AzureOpenAIConfig {
+    apiKey: string;
+    endpoint: string;
+    deployment: string;
+    apiVersion?: string;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface CompletionOptions {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    functionCall?: any;
+}
+export declare class AzureOpenAIClient {
+    private client;
+    private deployment;
+    constructor(config: AzureOpenAIConfig);
+    chat(options: CompletionOptions): Promise<string>;
+    chatWithFunctions(options: CompletionOptions & {
+        functions: any[];
+        functionCall?: any;
+    }): Promise<any>;
+    streamChat(options: CompletionOptions, onChunk: (text: string) => void): Promise<void>;
+    generateEmbedding(text: string): Promise<number[]>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,iBAAiB;IAU/B,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAWjD,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,GAAG;QAAE,SAAS,EAAE,GAAG,EAAE,CAAC;QAAC,YAAY,CAAC,EAAE,GAAG,CAAA;KAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IA0BtG,UAAU,CAAC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBtF,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAQzD"}

package/dist/client.js

@@ -0,0 +1,67 @@
+import OpenAI from 'openai';
+export class AzureOpenAIClient {
+    client;
+    deployment;
+    constructor(config) {
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: `${config.endpoint}/openai/deployments/${config.deployment}`,
+            defaultQuery: { 'api-version': config.apiVersion || '2024-08-01-preview' },
+            defaultHeaders: { 'api-key': config.apiKey },
+        });
+        this.deployment = config.deployment;
+    }
+    async chat(options) {
+        const response = await this.client.chat.completions.create({
+            model: this.deployment,
+            messages: options.messages,
+            temperature: options.temperature ?? 0.7,
+            max_tokens: options.maxTokens ?? 500,
+        });
+        return response.choices[0]?.message?.content || '';
+    }
+    async chatWithFunctions(options) {
+        const response = await this.client.chat.completions.create({
+            model: this.deployment,
+            messages: options.messages,
+            temperature: options.temperature ?? 0.7,
+            max_tokens: options.maxTokens ?? 500,
+            tools: options.functions.map(f => ({ type: 'function', function: f })),
+        });
+        const choice = response.choices[0];
+        if (choice?.message?.tool_calls?.[0]) {
+            const toolCall = choice.message.tool_calls[0];
+            return {
+                type: 'function',
+                name: toolCall.function.name,
+                arguments: JSON.parse(toolCall.function.arguments || '{}'),
+            };
+        }
+        return {
+            type: 'message',
+            content: choice?.message?.content || '',
+        };
+    }
+    async streamChat(options, onChunk) {
+        const stream = await this.client.chat.completions.create({
+            model: this.deployment,
+            messages: options.messages,
+            temperature: options.temperature ?? 0.7,
+            max_tokens: options.maxTokens ?? 500,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta?.content;
+            if (delta) {
+                onChunk(delta);
+            }
+        }
+    }
+    async generateEmbedding(text) {
+        const response = await this.client.embeddings.create({
+            model: 'text-embedding-3-small',
+            input: text,
+        });
+        return response.data[0]?.embedding || [];
+    }
+}

package/dist/fuzzy-matcher.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Fuzzy Command Matcher
+ * Handles misheard voice commands with intelligent correction
+ */
+export interface FuzzyMatchResult {
+    command: string;
+    confidence: number;
+    original: string;
+}
+export interface CommandSimilarityMap {
+    [key: string]: string[];
+}
+export declare class FuzzyMatcher {
+    private knownCommands;
+    private similarityMap;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private levenshteinDistance;
+    /**
+     * Find closest matching command using fuzzy matching
+     */
+    findClosestMatch(input: string): FuzzyMatchResult;
+    /**
+     * Check if input matches a known pattern exactly or closely
+     */
+    matchesKnownPattern(input: string): boolean;
+    /**
+     * Add custom commands to the matcher
+     */
+    addCommands(commands: string[]): void;
+    /**
+     * Add custom similarity mappings
+     */
+    addSimilarities(mappings: CommandSimilarityMap): void;
+    /**
+     * Get all known commands
+     */
+    getKnownCommands(): string[];
+}
+//# sourceMappingURL=fuzzy-matcher.d.ts.map

package/dist/fuzzy-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy-matcher.d.ts","sourceRoot":"","sources":["../src/fuzzy-matcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACzB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,aAAa,CAqBnB;IAEF,OAAO,CAAC,aAAa,CAgBnB;IAEF;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB;IAiDjD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAa3C;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAIrC;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAIrD;;OAEG;IACH,gBAAgB,IAAI,MAAM,EAAE;CAG7B"}

package/dist/fuzzy-matcher.js

@@ -0,0 +1,147 @@
+/**
+ * Fuzzy Command Matcher
+ * Handles misheard voice commands with intelligent correction
+ */
+export class FuzzyMatcher {
+    knownCommands = [
+        'scroll down',
+        'scroll up',
+        'scroll to top',
+        'scroll to bottom',
+        'go to home',
+        'go to features',
+        'go to about',
+        'go to contact',
+        'go to pricing',
+        'go to documentation',
+        'take me to home',
+        'take me to features',
+        'take me to about',
+        'take me to contact',
+        'fill my name',
+        'fill my email',
+        'fill my phone',
+        'stop listening',
+        'pause',
+        'quiet',
+    ];
+    similarityMap = {
+        scroll: ['stroll', 'install', 'crawl', 'role', 'scroll', 'role'],
+        top: ['dog', 'pop', 'cop', 'hop', 'top', 'tap', 'taco', 'stop'],
+        bottom: ['button', 'gotten', 'cotton', 'bottom', 'modern'],
+        down: ['town', 'noun', 'gown', 'down', 'done'],
+        up: ['cup', 'up', 'app'],
+        features: ['teachers', 'creatures', 'pictures', 'features'],
+        contact: ['contract', 'context', 'conduct', 'contact'],
+        about: ['a boat', 'shout', 'doubt', 'about', 'the boat'],
+        home: ['home', 'rome', 'ohm'],
+        'go to': ['go to', 'goto', 'go too', 'got to'],
+        fill: ['fill', 'feel', 'field'],
+        name: ['name', 'aim', 'main'],
+        email: ['email', 'e mail', 'meal'],
+        phone: ['phone', 'foam', 'zone'],
+        stop: ['stop', 'top', 'pause', 'quiet'],
+    };
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    levenshteinDistance(a, b) {
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
+                    matrix[i][j - 1] + 1, // insertion
+                    matrix[i - 1][j] + 1 // deletion
+                    );
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    /**
+     * Find closest matching command using fuzzy matching
+     */
+    findClosestMatch(input) {
+        input = input.toLowerCase().trim();
+        let bestMatch = '';
+        let bestScore = 0;
+        // First, try direct Levenshtein distance matching
+        for (const cmd of this.knownCommands) {
+            const distance = this.levenshteinDistance(input, cmd);
+            const maxLength = Math.max(input.length, cmd.length);
+            const score = 1 - distance / maxLength;
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatch = cmd;
+            }
+        }
+        // Then, check word-level similarity mapping
+        for (const [correct, variants] of Object.entries(this.similarityMap)) {
+            for (const variant of variants) {
+                if (input.includes(variant) && variant !== correct) {
+                    // Found a similar word, try correcting it
+                    const correctedCommand = input.replace(new RegExp(variant, 'gi'), correct);
+                    // Check if corrected command is closer to a known command
+                    for (const cmd of this.knownCommands) {
+                        const distance = this.levenshteinDistance(correctedCommand, cmd);
+                        const maxLength = Math.max(correctedCommand.length, cmd.length);
+                        const score = 1 - distance / maxLength;
+                        // Boost score for similarity map matches
+                        const boostedScore = Math.min(score * 1.15, 1.0);
+                        if (boostedScore > bestScore) {
+                            bestScore = boostedScore;
+                            bestMatch = cmd;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            command: bestMatch,
+            confidence: bestScore,
+            original: input,
+        };
+    }
+    /**
+     * Check if input matches a known pattern exactly or closely
+     */
+    matchesKnownPattern(input) {
+        input = input.toLowerCase();
+        const patterns = [
+            /\b(go to|take me to|navigate to)\b/,
+            /\b(scroll)\b/,
+            /\b(name|email|phone)\b/,
+            /\b(stop|pause|quiet)\b/,
+            /\b(fill|enter)\b/,
+        ];
+        return patterns.some(pattern => pattern.test(input));
+    }
+    /**
+     * Add custom commands to the matcher
+     */
+    addCommands(commands) {
+        this.knownCommands.push(...commands);
+    }
+    /**
+     * Add custom similarity mappings
+     */
+    addSimilarities(mappings) {
+        this.similarityMap = { ...this.similarityMap, ...mappings };
+    }
+    /**
+     * Get all known commands
+     */
+    getKnownCommands() {
+        return [...this.knownCommands];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { AzureOpenAIClient } from './client.js';
+export { IntentClassifier } from './intent/classifier.js';
+export { ActionRouter } from './actions/index.js';
+export { FuzzyMatcher } from './fuzzy-matcher.js';
+export { ResponseGenerator } from './responses/generator.js';
+export * from './intent/types.js';
+export * from './actions/index.js';
+export * from './prompts/index.js';
+export type { AzureOpenAIConfig, ChatMessage, CompletionOptions } from './client.js';
+export type { FuzzyMatchResult, CommandSimilarityMap } from './fuzzy-matcher.js';
+export type { ResponseTemplates } from './responses/generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AAEnC,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrF,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACjF,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { AzureOpenAIClient } from './client.js';
+export { IntentClassifier } from './intent/classifier.js';
+export { ActionRouter } from './actions/index.js';
+export { FuzzyMatcher } from './fuzzy-matcher.js';
+export { ResponseGenerator } from './responses/generator.js';
+export * from './intent/types.js';
+export * from './actions/index.js';
+export * from './prompts/index.js';

package/dist/intent/classifier.d.ts

@@ -0,0 +1,20 @@
+import { AzureOpenAIClient } from '../client.js';
+import { Intent, IntentResult } from './types.js';
+export declare class IntentClassifier {
+    private client;
+    private fuzzyMatcher;
+    constructor(client: AzureOpenAIClient);
+    classify(userInput: string, context?: {
+        pageTitle?: string;
+        availableLinks?: string[];
+    }): Promise<IntentResult>;
+    /**
+     * Parse a fuzzy matched command string into an IntentResult
+     */
+    private parseCommandToIntent;
+    private buildSystemPrompt;
+    private buildUserPrompt;
+    private parseIntentResponse;
+    extractEntities(userInput: string, intentType: Intent): Promise<Record<string, any>>;
+}
+//# sourceMappingURL=classifier.d.ts.map

package/dist/intent/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../src/intent/classifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAe,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,YAAY,CAAe;gBAEvB,MAAM,EAAE,iBAAiB;IAK/B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC;IAmDrH;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyD5B,OAAO,CAAC,iBAAiB;IAgCzB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,mBAAmB;IAmCrB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CA4B3F"}

package/dist/intent/classifier.js

@@ -0,0 +1,198 @@
+import { Intent } from './types.js';
+import { FuzzyMatcher } from '../fuzzy-matcher.js';
+export class IntentClassifier {
+    client;
+    fuzzyMatcher;
+    constructor(client) {
+        this.client = client;
+        this.fuzzyMatcher = new FuzzyMatcher();
+    }
+    async classify(userInput, context) {
+        // First try fuzzy matching for known commands
+        const fuzzyMatch = this.fuzzyMatcher.findClosestMatch(userInput);
+        // If high confidence match, use it directly
+        if (fuzzyMatch.confidence > 0.85) {
+            console.log(`[IntentClassifier] Fuzzy match found: ${fuzzyMatch.command} (confidence: ${fuzzyMatch.confidence})`);
+            // Parse the fuzzy matched command into an intent
+            return this.parseCommandToIntent(fuzzyMatch.command, userInput, fuzzyMatch.confidence);
+        }
+        // Otherwise, use LLM for classification
+        const systemPrompt = this.buildSystemPrompt(context);
+        const userPrompt = this.buildUserPrompt(userInput);
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: userPrompt },
+        ];
+        try {
+            const response = await this.client.chat({ messages, temperature: 0.3, maxTokens: 200 });
+            const result = this.parseIntentResponse(response, userInput);
+            // If LLM confidence is low, suggest fuzzy match
+            if (result.confidence < 0.6 && fuzzyMatch.confidence > 0.6) {
+                return {
+                    ...result,
+                    suggestedCommand: fuzzyMatch.command,
+                    suggestedConfidence: fuzzyMatch.confidence,
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('Intent classification failed:', error);
+            // Fallback to fuzzy matching
+            if (fuzzyMatch.confidence > 0.5) {
+                return this.parseCommandToIntent(fuzzyMatch.command, userInput, fuzzyMatch.confidence);
+            }
+            return {
+                intent: Intent.UNKNOWN,
+                confidence: 0,
+                entities: {},
+                rawText: userInput,
+            };
+        }
+    }
+    /**
+     * Parse a fuzzy matched command string into an IntentResult
+     */
+    parseCommandToIntent(command, rawText, confidence) {
+        command = command.toLowerCase();
+        // Scroll commands
+        if (command.includes('scroll')) {
+            let direction = 'down';
+            if (command.includes('up'))
+                direction = 'up';
+            else if (command.includes('top'))
+                direction = 'top';
+            else if (command.includes('bottom'))
+                direction = 'bottom';
+            return {
+                intent: Intent.SCROLL,
+                confidence,
+                entities: { direction },
+                rawText,
+            };
+        }
+        // Navigation commands
+        if (command.includes('go to') || command.includes('take me to')) {
+            const target = command.replace(/^(go to|take me to)\s+/, '');
+            return {
+                intent: Intent.NAVIGATE,
+                confidence,
+                entities: { target },
+                rawText,
+            };
+        }
+        // Form fill commands
+        if (command.includes('fill')) {
+            return {
+                intent: Intent.FORM_FILL,
+                confidence,
+                entities: {},
+                rawText,
+            };
+        }
+        // Stop commands
+        if (command.includes('stop') || command.includes('pause') || command.includes('quiet')) {
+            return {
+                intent: Intent.UNKNOWN, // Special case - handled at UI level
+                confidence,
+                entities: { action: 'stop' },
+                rawText,
+            };
+        }
+        return {
+            intent: Intent.UNKNOWN,
+            confidence: 0,
+            entities: {},
+            rawText,
+        };
+    }
+    buildSystemPrompt(context) {
+        let prompt = `You are an intent classifier for a voice navigation system. Classify user voice commands into one of these intents:
+
+- NAVIGATE: User wants to go to a different page (e.g., "go to products", "take me to about us")
+- FORM_FILL: User wants to fill a form field (e.g., "my name is John", "enter email as test@test.com")
+- QUESTION: User is asking a question about the website (e.g., "what is your refund policy?")
+- READ_PAGE: User wants to hear page content (e.g., "read this page", "what's on this page?")
+- CLICK: User wants to click something (e.g., "click the submit button", "press login")
+- SCROLL: User wants to scroll (e.g., "scroll down", "go to top")
+- SEARCH: User wants to search (e.g., "search for laptops")
+- UNKNOWN: None of the above
+
+Respond in this exact JSON format:
+{
+  "intent": "NAVIGATE",
+  "confidence": 0.95,
+  "entities": {
+    "target": "products"
+  }
+}`;
+        if (context?.pageTitle) {
+            prompt += `\n\nCurrent page: ${context.pageTitle}`;
+        }
+        if (context?.availableLinks && context.availableLinks.length > 0) {
+            prompt += `\n\nAvailable navigation links: ${context.availableLinks.slice(0, 10).join(', ')}`;
+        }
+        return prompt;
+    }
+    buildUserPrompt(userInput) {
+        return `Classify this command: "${userInput}"`;
+    }
+    parseIntentResponse(response, rawText) {
+        try {
+            const cleaned = response.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+            const parsed = JSON.parse(cleaned);
+            const intentMap = {
+                NAVIGATE: Intent.NAVIGATE,
+                FORM_FILL: Intent.FORM_FILL,
+                QUESTION: Intent.QUESTION,
+                READ_PAGE: Intent.READ_PAGE,
+                CLICK: Intent.CLICK,
+                SCROLL: Intent.SCROLL,
+                SEARCH: Intent.SEARCH,
+                UNKNOWN: Intent.UNKNOWN,
+            };
+            const intent = intentMap[parsed.intent?.toUpperCase()] || Intent.UNKNOWN;
+            return {
+                intent,
+                confidence: parsed.confidence || 0.5,
+                entities: parsed.entities || {},
+                rawText,
+            };
+        }
+        catch (error) {
+            console.error('Failed to parse intent response:', error);
+            return {
+                intent: Intent.UNKNOWN,
+                confidence: 0,
+                entities: {},
+                rawText,
+            };
+        }
+    }
+    async extractEntities(userInput, intentType) {
+        const prompts = {
+            [Intent.NAVIGATE]: `Extract the target page/section from: "${userInput}". Return JSON: {"target": "page name"}`,
+            [Intent.FORM_FILL]: `Extract field name and value from: "${userInput}". Return JSON: {"fieldName": "name", "fieldValue": "value"}`,
+            [Intent.QUESTION]: `Extract the question from: "${userInput}". Return JSON: {"question": "the question"}`,
+            [Intent.READ_PAGE]: `Extract section if mentioned: "${userInput}". Return JSON: {"section": "section name or null"}`,
+            [Intent.CLICK]: `Extract what to click from: "${userInput}". Return JSON: {"target": "element description"}`,
+            [Intent.SCROLL]: `Extract scroll direction from: "${userInput}". Return JSON: {"direction": "up|down|top|bottom"}`,
+            [Intent.SEARCH]: `Extract search query from: "${userInput}". Return JSON: {"query": "search terms"}`,
+            [Intent.UNKNOWN]: `{}`,
+        };
+        const prompt = prompts[intentType] || '{}';
+        try {
+            const response = await this.client.chat({
+                messages: [{ role: 'user', content: prompt }],
+                temperature: 0.2,
+                maxTokens: 100,
+            });
+            const cleaned = response.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+            return JSON.parse(cleaned);
+        }
+        catch (error) {
+            console.error('Entity extraction failed:', error);
+            return {};
+        }
+    }
+}

package/dist/intent/types.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare enum Intent {
+    NAVIGATE = "navigate",
+    FORM_FILL = "form_fill",
+    QUESTION = "question",
+    READ_PAGE = "read_page",
+    SCROLL = "scroll",
+    CLICK = "click",
+    SEARCH = "search",
+    UNKNOWN = "unknown"
+}
+export declare const IntentSchema: z.ZodObject<{
+    intent: z.ZodNativeEnum<typeof Intent>;
+    confidence: z.ZodNumber;
+    entities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    rawText: z.ZodString;
+    suggestedCommand: z.ZodOptional<z.ZodString>;
+    suggestedConfidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    intent: Intent;
+    confidence: number;
+    rawText: string;
+    entities?: Record<string, any> | undefined;
+    suggestedCommand?: string | undefined;
+    suggestedConfidence?: number | undefined;
+}, {
+    intent: Intent;
+    confidence: number;
+    rawText: string;
+    entities?: Record<string, any> | undefined;
+    suggestedCommand?: string | undefined;
+    suggestedConfidence?: number | undefined;
+}>;
+export type IntentResult = z.infer<typeof IntentSchema>;
+export interface NavigateIntent {
+    intent: Intent.NAVIGATE;
+    targetPage: string;
+    linkText?: string;
+}
+export interface FormFillIntent {
+    intent: Intent.FORM_FILL;
+    fieldName: string;
+    fieldValue: string;
+    fieldType?: string;
+}
+export interface QuestionIntent {
+    intent: Intent.QUESTION;
+    question: string;
+}
+export interface ReadPageIntent {
+    intent: Intent.READ_PAGE;
+    section?: string;
+}
+export interface ClickIntent {
+    intent: Intent.CLICK;
+    target: string;
+}
+export interface ScrollIntent {
+    intent: Intent.SCROLL;
+    direction: 'up' | 'down' | 'top' | 'bottom';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/intent/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/intent/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,MAAM;IAChB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;IACtB,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;CAC7C"}

package/dist/intent/types.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export var Intent;
+(function (Intent) {
+    Intent["NAVIGATE"] = "navigate";
+    Intent["FORM_FILL"] = "form_fill";
+    Intent["QUESTION"] = "question";
+    Intent["READ_PAGE"] = "read_page";
+    Intent["SCROLL"] = "scroll";
+    Intent["CLICK"] = "click";
+    Intent["SEARCH"] = "search";
+    Intent["UNKNOWN"] = "unknown";
+})(Intent || (Intent = {}));
+export const IntentSchema = z.object({
+    intent: z.nativeEnum(Intent),
+    confidence: z.number().min(0).max(1),
+    entities: z.record(z.any()).optional(),
+    rawText: z.string(),
+    suggestedCommand: z.string().optional(),
+    suggestedConfidence: z.number().min(0).max(1).optional(),
+});

package/dist/prompts/index.d.ts

@@ -0,0 +1,12 @@
+export declare const INTENT_CLASSIFICATION_PROMPT = "You are an AI assistant for voice navigation. Classify user intents and help them navigate websites.";
+export declare const FORM_FILL_PROMPT = "You are helping a user fill out a web form using voice commands. Extract field names and values from their speech.";
+export declare const NAVIGATION_PROMPT = "You are helping a user navigate a website using voice. Match their request to available links or pages.";
+export declare const QA_PROMPT = "You are answering user questions about a website. Provide concise, helpful answers based on the provided context.";
+export declare const PAGE_SUMMARY_PROMPT = "Summarize this webpage content in 2-3 sentences for voice reading. Focus on the main purpose and key information.";
+export declare function buildContextPrompt(context: {
+    pageTitle?: string;
+    headings?: string[];
+    links?: string[];
+    content?: string;
+}): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,yGAAyG,CAAC;AAEnJ,eAAO,MAAM,gBAAgB,uHAAuH,CAAC;AAErJ,eAAO,MAAM,iBAAiB,4GAA4G,CAAC;AAE3I,eAAO,MAAM,SAAS,sHAAsH,CAAC;AAE7I,eAAO,MAAM,mBAAmB,sHAAsH,CAAC;AAEvJ,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAqBT"}

package/dist/prompts/index.js

@@ -0,0 +1,22 @@
+export const INTENT_CLASSIFICATION_PROMPT = `You are an AI assistant for voice navigation. Classify user intents and help them navigate websites.`;
+export const FORM_FILL_PROMPT = `You are helping a user fill out a web form using voice commands. Extract field names and values from their speech.`;
+export const NAVIGATION_PROMPT = `You are helping a user navigate a website using voice. Match their request to available links or pages.`;
+export const QA_PROMPT = `You are answering user questions about a website. Provide concise, helpful answers based on the provided context.`;
+export const PAGE_SUMMARY_PROMPT = `Summarize this webpage content in 2-3 sentences for voice reading. Focus on the main purpose and key information.`;
+export function buildContextPrompt(context) {
+    let prompt = 'Current page context:\n';
+    if (context.pageTitle) {
+        prompt += `Page title: ${context.pageTitle}\n`;
+    }
+    if (context.headings && context.headings.length > 0) {
+        prompt += `Headings: ${context.headings.slice(0, 5).join(', ')}\n`;
+    }
+    if (context.links && context.links.length > 0) {
+        prompt += `Available links: ${context.links.slice(0, 10).join(', ')}\n`;
+    }
+    if (context.content) {
+        const truncated = context.content.substring(0, 500);
+        prompt += `Content preview: ${truncated}...\n`;
+    }
+    return prompt;
+}

package/dist/responses/generator.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Conversational Response Generator
+ * Provides natural, friendly voice responses with variety
+ */
+export interface ResponseTemplates {
+    navigation: {
+        success: string[];
+        notFound: string[];
+    };
+    scroll: {
+        down: string[];
+        up: string[];
+        top: string[];
+        bottom: string[];
+    };
+    clarification: {
+        didYouMean: string;
+        notUnderstood: string;
+        suggestions: string;
+        cancelConfirmation: string;
+    };
+    formFill: {
+        name: string;
+        email: string;
+        phone: string;
+        partial: string;
+    };
+    stop: string[];
+}
+export declare class ResponseGenerator {
+    private templates;
+    /**
+     * Get a random response from an array for variety
+     */
+    private getRandomResponse;
+    /**
+     * Replace placeholders in template strings
+     */
+    private interpolate;
+    /**
+     * Generate navigation success response
+     */
+    navigationSuccess(target: string): string;
+    /**
+     * Generate navigation not found response
+     */
+    navigationNotFound(target: string): string;
+    /**
+     * Generate scroll response
+     */
+    scroll(direction: 'up' | 'down' | 'top' | 'bottom'): string;
+    /**
+     * Generate "did you mean" clarification
+     */
+    didYouMean(suggestion: string): string;
+    /**
+     * Generate not understood response
+     */
+    notUnderstood(): string;
+    /**
+     * Generate suggestions response
+     */
+    suggestions(): string;
+    /**
+     * Generate cancel confirmation response
+     */
+    cancelConfirmation(): string;
+    /**
+     * Generate form fill response
+     */
+    formFill(field: 'name' | 'email' | 'phone' | 'partial'): string;
+    /**
+     * Generate stop response
+     */
+    stop(): string;
+    /**
+     * Update response templates (for customization)
+     */
+    updateTemplates(templates: Partial<ResponseTemplates>): void;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/responses/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/responses/generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE;QACV,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,EAAE,EAAE,MAAM,EAAE,CAAC;QACb,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;IACF,aAAa,EAAE;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;QACpB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CA+Df;IAEF;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKzC;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAK1C;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM;IAI3D;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAItC;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM;IAI/D;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;CAG7D"}

package/dist/responses/generator.js

@@ -0,0 +1,148 @@
+/**
+ * Conversational Response Generator
+ * Provides natural, friendly voice responses with variety
+ */
+export class ResponseGenerator {
+    templates = {
+        navigation: {
+            success: [
+                "Sure, taking you to {target} now",
+                "Alright, heading to {target}",
+                "On my way to {target}",
+                "Got it, navigating to {target}",
+                "Let me take you to {target}",
+            ],
+            notFound: [
+                "Hmm, I couldn't find {target}. Try saying something like 'go to features' or 'go to contact'",
+                "I don't see a {target} section. What else can I help you find?",
+                "Sorry, I couldn't locate {target}. You can try other sections available on this page",
+            ],
+        },
+        scroll: {
+            down: [
+                "Scrolling down for you",
+                "Going down",
+                "Sure, scrolling down",
+                "Moving down the page",
+                "Let me scroll down",
+            ],
+            up: [
+                "Scrolling up",
+                "Going back up",
+                "Sure, scrolling up",
+                "Moving up the page",
+                "Let me scroll up",
+            ],
+            top: [
+                "Taking you to the top",
+                "Back to the top we go",
+                "Sure, going to the top",
+                "Heading to the top",
+                "Let me take you to the top",
+            ],
+            bottom: [
+                "Scrolling to the bottom",
+                "Taking you all the way down",
+                "Sure, going to the bottom",
+                "Heading to the bottom",
+                "Let me scroll to the bottom",
+            ],
+        },
+        clarification: {
+            didYouMean: "Did you mean '{suggestion}'? Say yes to confirm or try again",
+            notUnderstood: "I didn't quite catch that. Could you try saying it differently?",
+            suggestions: "You can try commands like 'scroll down', 'go to contact', or 'fill my name as John'",
+            cancelConfirmation: "No problem. What would you like to do instead?",
+        },
+        formFill: {
+            name: "Got it! I've filled in your name",
+            email: "Perfect! I've added your email",
+            phone: "All set! I've filled in your phone number",
+            partial: "I filled what I could. Want to add anything else?",
+        },
+        stop: [
+            "Alright, turning off the voice assistant",
+            "No problem, stopping now",
+            "Got it, voice assistant off",
+            "Sure, I'll stop listening",
+        ],
+    };
+    /**
+     * Get a random response from an array for variety
+     */
+    getRandomResponse(responses) {
+        return responses[Math.floor(Math.random() * responses.length)];
+    }
+    /**
+     * Replace placeholders in template strings
+     */
+    interpolate(template, values) {
+        let result = template;
+        for (const [key, value] of Object.entries(values)) {
+            result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
+        }
+        return result;
+    }
+    /**
+     * Generate navigation success response
+     */
+    navigationSuccess(target) {
+        const template = this.getRandomResponse(this.templates.navigation.success);
+        return this.interpolate(template, { target });
+    }
+    /**
+     * Generate navigation not found response
+     */
+    navigationNotFound(target) {
+        const template = this.getRandomResponse(this.templates.navigation.notFound);
+        return this.interpolate(template, { target });
+    }
+    /**
+     * Generate scroll response
+     */
+    scroll(direction) {
+        return this.getRandomResponse(this.templates.scroll[direction]);
+    }
+    /**
+     * Generate "did you mean" clarification
+     */
+    didYouMean(suggestion) {
+        return this.interpolate(this.templates.clarification.didYouMean, { suggestion });
+    }
+    /**
+     * Generate not understood response
+     */
+    notUnderstood() {
+        return this.templates.clarification.notUnderstood;
+    }
+    /**
+     * Generate suggestions response
+     */
+    suggestions() {
+        return this.templates.clarification.suggestions;
+    }
+    /**
+     * Generate cancel confirmation response
+     */
+    cancelConfirmation() {
+        return this.templates.clarification.cancelConfirmation;
+    }
+    /**
+     * Generate form fill response
+     */
+    formFill(field) {
+        return this.templates.formFill[field];
+    }
+    /**
+     * Generate stop response
+     */
+    stop() {
+        return this.getRandomResponse(this.templates.stop);
+    }
+    /**
+     * Update response templates (for customization)
+     */
+    updateTemplates(templates) {
+        this.templates = { ...this.templates, ...templates };
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "voicepilot-llm-engine",
+  "version": "0.1.0",
+  "description": "LLM engine with fuzzy matching and conversational responses",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "openai": "^4.77.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@voicepilot/typescript-config": "workspace:*",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}