floating-copilot-widget 1.4.3 → 1.5.1

package/dist/services/copilot.d.ts

@@ -0,0 +1,91 @@
+/**
+ * GitHub Copilot Integration Service
+ *
+ * Provides AI-powered intent analysis and API integration for the floating chat widget.
+ * Uses GitHub's Models API (backed by OpenAI GPT-4) for intelligent message understanding.
+ *
+ * To use this service, you need a GitHub Personal Access Token with appropriate scopes.
+ */
+import type { CopilotConfig, CopilotIntentRequest, CopilotIntentResponse, APIIntegration, APICallRequest, APICallResponse } from '../types/copilot';
+export * from '../types/copilot';
+/**
+ * Analyze user message to identify intent and extract parameters
+ */
+export declare function analyzeUserIntent(request: CopilotIntentRequest, config: CopilotConfig, availableApis?: APIIntegration[]): Promise<CopilotIntentResponse>;
+/**
+ * Call an API integration based on intent and parameters
+ */
+export declare function callAPI(request: APICallRequest, integration: APIIntegration): Promise<APICallResponse>;
+/**
+ * Process user message: analyze intent and call appropriate API
+ */
+export declare function processUserMessage(userMessage: string, config: CopilotConfig, availableApis: APIIntegration[], context?: Record<string, any>): Promise<{
+    intent: CopilotIntentResponse;
+    apiResponse?: APICallResponse;
+}>;
+/**
+ * Validate that GitHub token is available before processing
+ * Useful for early validation in applications
+ */
+export declare function validateGithubToken(config: CopilotConfig): {
+    valid: boolean;
+    token?: string;
+    error?: string;
+};
+/**
+ * Generate a user-friendly response from intent and API data
+ */
+export declare function generateCopilotResponse(userMessage: string, intentResponse: CopilotIntentResponse, apiResponse?: APICallResponse, config?: CopilotConfig): Promise<string>;
+/**
+ * Validate API integration configuration
+ */
+export declare function validateAPIIntegration(api: APIIntegration): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Merge multiple API integrations from different sources
+ */
+export declare function mergeAPIIntegrations(...integrationSets: APIIntegration[][]): APIIntegration[];
+/**
+ * Get missing required parameters for an API
+ */
+export declare function getMissingParameters(api: APIIntegration, providedParams: Record<string, any>): string[];
+/**
+ * Get the next missing parameter to ask for
+ */
+export declare function getNextMissingParameter(api: APIIntegration, providedParams: Record<string, any>): {
+    parameter: string;
+    description: string;
+    example?: string;
+    type?: string;
+} | null;
+/**
+ * Validate a parameter value against its definition
+ */
+export declare function validateParameter(paramName: string, value: any, definition: {
+    type?: string;
+    validation?: string;
+}): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Check if all required parameters have been collected
+ */
+export declare function areAllParametersCollected(api: APIIntegration, providedParams: Record<string, any>): boolean;
+/**
+ * Collect parameters interactively
+ * Returns a system prompt asking for the next missing parameter
+ * OR triggers API call if all parameters are collected
+ */
+export declare function generateParameterPromptOrCallAPI(api: APIIntegration, providedParams: Record<string, any>, intent: string, context?: Record<string, any>): Promise<{
+    prompt?: string;
+    apiResponse?: APICallResponse;
+    allParametersCollected: boolean;
+}>;
+/**
+ * Collect parameters interactively
+ * Returns a system prompt asking for the next missing parameter
+ */
+export declare function generateParameterPrompt(api: APIIntegration, providedParams: Record<string, any>): string;

package/dist/services/copilot.js

@@ -0,0 +1,503 @@
+/**
+ * GitHub Copilot Integration Service
+ *
+ * Provides AI-powered intent analysis and API integration for the floating chat widget.
+ * Uses GitHub's Models API (backed by OpenAI GPT-4) for intelligent message understanding.
+ *
+ * To use this service, you need a GitHub Personal Access Token with appropriate scopes.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export * from '../types/copilot';
+const GITHUB_COPILOT_MODELS = 'https://models.inference.ai.azure.com/chat/completions';
+/**
+ * Get GitHub token from config or environment variables
+ */
+function getGithubToken(configToken) {
+    var _a, _b, _c;
+    // 1. Use explicitly provided token from config
+    if (configToken) {
+        return configToken;
+    }
+    // 2. Check common environment variable names
+    const token = (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.GITHUB_TOKEN)) ||
+        (typeof process !== 'undefined' && ((_b = process.env) === null || _b === void 0 ? void 0 : _b.VITE_GITHUB_TOKEN)) ||
+        (typeof process !== 'undefined' && ((_c = process.env) === null || _c === void 0 ? void 0 : _c.REACT_APP_GITHUB_TOKEN)) ||
+        (typeof window !== 'undefined' && window.__GITHUB_TOKEN__);
+    if (!token) {
+        throw new Error('GitHub token is required for Copilot integration. ' +
+            'Provide it via:\n' +
+            '1. CopilotConfig.githubToken parameter\n' +
+            '2. Environment variable: GITHUB_TOKEN, VITE_GITHUB_TOKEN, or REACT_APP_GITHUB_TOKEN\n' +
+            '3. Global variable: window.__GITHUB_TOKEN__\n\n' +
+            'Get token from: https://github.com/settings/tokens (scopes: copilot, read:user)');
+    }
+    return token;
+}
+/**
+ * Analyze user message to identify intent and extract parameters
+ */
+export function analyzeUserIntent(request, config, availableApis) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { userMessage, context, customInstructions } = request;
+        const { model = 'gpt-4o', maxTokens = 2000 } = config;
+        const githubToken = getGithubToken(config.githubToken);
+        // Build system prompt
+        const systemPrompt = buildIntentSystemPrompt(availableApis, customInstructions);
+        // Build user prompt
+        const userPrompt = buildIntentUserPrompt(userMessage, context, availableApis);
+        try {
+            const response = yield fetch(GITHUB_COPILOT_MODELS, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${githubToken}`,
+                    'Content-Type': 'application/json',
+                    'X-GitHub-Api-Version': '2022-11-28'
+                },
+                body: JSON.stringify({
+                    model: model,
+                    messages: [
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ],
+                    max_tokens: maxTokens,
+                    temperature: 0.3
+                })
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`Copilot API error (${response.status}): ${errorText}`);
+            }
+            const data = yield response.json();
+            const content = (_c = (_b = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content;
+            if (!content) {
+                throw new Error('No response received from Copilot');
+            }
+            // Parse the intent response
+            return parseIntentResponse(content, userMessage);
+        }
+        catch (error) {
+            throw new Error(`Failed to analyze intent: ${error.message}`);
+        }
+    });
+}
+/**
+ * Call an API integration based on intent and parameters
+ */
+export function callAPI(request, integration) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Build the request
+            const apiRequest = integration.buildRequest(request.parameters, request.context);
+            // Prepare fetch options
+            const fetchOptions = {
+                method: integration.method,
+                headers: Object.assign({ 'Content-Type': 'application/json' }, integration.headers)
+            };
+            // Add body for non-GET requests
+            if (integration.method !== 'GET' && apiRequest) {
+                fetchOptions.body = typeof apiRequest === 'string' ? apiRequest : JSON.stringify(apiRequest);
+            }
+            // Make the API call
+            const response = yield fetch(integration.endpoint, fetchOptions);
+            if (!response.ok) {
+                const errorText = yield response.text();
+                return {
+                    success: false,
+                    error: `API error (${response.status}): ${errorText}`,
+                    apiName: integration.name
+                };
+            }
+            const responseData = yield response.json();
+            // Format the response
+            const formattedData = integration.formatResponse(responseData);
+            return {
+                success: true,
+                data: formattedData,
+                rawData: responseData,
+                apiName: integration.name
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to call API: ${error.message}`,
+                apiName: integration.name
+            };
+        }
+    });
+}
+/**
+ * Process user message: analyze intent and call appropriate API
+ */
+export function processUserMessage(userMessage, config, availableApis, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Validate token is available early
+        getGithubToken(config.githubToken);
+        // Step 1: Analyze intent
+        const intentResponse = yield analyzeUserIntent({ userMessage, context }, config, availableApis);
+        // Step 2: Determine which API to call
+        let apiResponse;
+        if (intentResponse.suggestedApis.length > 0) {
+            const apiId = intentResponse.suggestedApis[0];
+            const api = availableApis.find(a => a.id === apiId);
+            if (api) {
+                // Check if API should be called for this intent
+                const shouldCall = api.shouldCall
+                    ? api.shouldCall(intentResponse.intent, intentResponse.parameters)
+                    : true;
+                if (shouldCall) {
+                    apiResponse = yield callAPI({
+                        apiId,
+                        parameters: intentResponse.parameters,
+                        context
+                    }, api);
+                }
+            }
+        }
+        return {
+            intent: intentResponse,
+            apiResponse
+        };
+    });
+}
+/**
+ * Validate that GitHub token is available before processing
+ * Useful for early validation in applications
+ */
+export function validateGithubToken(config) {
+    try {
+        const token = getGithubToken(config.githubToken);
+        return { valid: true, token };
+    }
+    catch (error) {
+        return { valid: false, error: error.message };
+    }
+}
+/**
+ * Generate a user-friendly response from intent and API data
+ */
+export function generateCopilotResponse(userMessage, intentResponse, apiResponse, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // If we have API response data, return it
+        if ((apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.success) && apiResponse.data) {
+            return apiResponse.data;
+        }
+        // If API call failed, explain the error
+        if (apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.error) {
+            return `I encountered an error while processing your request: ${apiResponse.error}`;
+        }
+        // If no API was called but we have intent analysis
+        if (intentResponse.intent && intentResponse.confidence > 0.5) {
+            return `I understand you want to: ${intentResponse.intent}
+
+Parameters identified:
+${Object.entries(intentResponse.parameters)
+                .map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`)
+                .join('\n')}
+
+However, no API integration is available for this intent. Please check the available integrations.`;
+        }
+        // Fallback response
+        return `I'm not sure what you're asking. Could you provide more details?`;
+    });
+}
+/**
+ * Build system prompt for intent analysis
+ */
+function buildIntentSystemPrompt(availableApis, customInstructions) {
+    let prompt = `You are an intelligent intent analyzer integrated into a chat application.
+Your role is to understand user messages and identify the user's intent, extract relevant parameters, and suggest which API integrations to use.
+
+RESPONSE FORMAT:
+You MUST respond ONLY with a valid JSON object in this exact format:
+{
+  "intent": "description of what the user wants",
+  "confidence": 0.95,
+  "parameters": {
+    "param1": "value1",
+    "param2": "value2"
+  },
+  "suggestedApis": ["api_id_1", "api_id_2"]
+}
+
+IMPORTANT:
+- intent: A clear description of what the user wants to accomplish
+- confidence: A number between 0 and 1 indicating how confident you are
+- parameters: Key-value pairs of information extracted from the message
+- suggestedApis: Array of API IDs that should be called (in order of preference)
+
+Be conversational, helpful, and focus on understanding the user's actual need.`;
+    if (availableApis && availableApis.length > 0) {
+        prompt += `\n\nAVAILABLE API INTEGRATIONS:\n`;
+        availableApis.forEach(api => {
+            prompt += `\n- ID: ${api.id}\n  Name: ${api.name}\n  Description: ${api.name}`;
+            if (api.intents) {
+                prompt += `\n  Intended for intents: ${api.intents.join(', ')}`;
+            }
+        });
+    }
+    if (customInstructions) {
+        prompt += `\n\nCUSTOM INSTRUCTIONS:\n${customInstructions}`;
+    }
+    return prompt;
+}
+/**
+ * Build user prompt for intent analysis
+ */
+function buildIntentUserPrompt(userMessage, context, availableApis) {
+    let prompt = `Analyze this user message and respond with ONLY a valid JSON object (no markdown, no extra text):
+
+User message: "${userMessage}"`;
+    if (context && Object.keys(context).length > 0) {
+        prompt += `\n\nContext information:\n`;
+        Object.entries(context).forEach(([key, value]) => {
+            prompt += `- ${key}: ${JSON.stringify(value)}\n`;
+        });
+    }
+    prompt += `\n\nRespond with ONLY the JSON object, no other text.`;
+    return prompt;
+}
+/**
+ * Parse intent response from Copilot
+ */
+function parseIntentResponse(content, userMessage) {
+    try {
+        // Extract JSON from potential markdown code blocks
+        let jsonContent = content.trim();
+        const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+        if (jsonMatch) {
+            jsonContent = jsonMatch[1];
+        }
+        const parsed = JSON.parse(jsonContent);
+        return {
+            intent: parsed.intent || 'unknown',
+            confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.5,
+            parameters: parsed.parameters || {},
+            suggestedApis: Array.isArray(parsed.suggestedApis) ? parsed.suggestedApis : [],
+            rawResponse: content
+        };
+    }
+    catch (error) {
+        // Fallback parsing if JSON parsing fails
+        return {
+            intent: 'user_query',
+            confidence: 0.3,
+            parameters: { query: userMessage },
+            suggestedApis: [],
+            rawResponse: content
+        };
+    }
+}
+/**
+ * Validate API integration configuration
+ */
+export function validateAPIIntegration(api) {
+    const errors = [];
+    if (!api.id)
+        errors.push('API must have an id');
+    if (!api.name)
+        errors.push('API must have a name');
+    if (!api.endpoint)
+        errors.push('API must have an endpoint');
+    if (!api.method)
+        errors.push('API must have a method');
+    if (!api.buildRequest || typeof api.buildRequest !== 'function') {
+        errors.push('API must have a buildRequest function');
+    }
+    if (!api.formatResponse || typeof api.formatResponse !== 'function') {
+        errors.push('API must have a formatResponse function');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Merge multiple API integrations from different sources
+ */
+export function mergeAPIIntegrations(...integrationSets) {
+    const merged = new Map();
+    integrationSets.forEach(set => {
+        set.forEach(api => {
+            const validation = validateAPIIntegration(api);
+            if (validation.valid) {
+                merged.set(api.id, api);
+            }
+            else {
+                console.warn(`Invalid API integration ${api.id}:`, validation.errors);
+            }
+        });
+    });
+    return Array.from(merged.values());
+}
+/**
+ * Get missing required parameters for an API
+ */
+export function getMissingParameters(api, providedParams) {
+    if (!api.requiredParameters || api.requiredParameters.length === 0) {
+        return [];
+    }
+    return api.requiredParameters
+        .filter(param => param.required !== false && !providedParams[param.name])
+        .map(param => param.name);
+}
+/**
+ * Get the next missing parameter to ask for
+ */
+export function getNextMissingParameter(api, providedParams) {
+    if (!api.requiredParameters || api.requiredParameters.length === 0) {
+        return null;
+    }
+    const missing = api.requiredParameters.find(param => param.required !== false && !providedParams[param.name]);
+    if (!missing) {
+        return null;
+    }
+    return {
+        parameter: missing.name,
+        description: missing.description,
+        example: missing.example,
+        type: missing.type
+    };
+}
+/**
+ * Validate a parameter value against its definition
+ */
+export function validateParameter(paramName, value, definition) {
+    if (!value) {
+        return { valid: false, error: `${paramName} cannot be empty` };
+    }
+    // Type validation
+    if (definition.type) {
+        switch (definition.type) {
+            case 'email':
+                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                    return { valid: false, error: `${paramName} must be a valid email address` };
+                }
+                break;
+            case 'phone':
+                if (!/^[\d\s\-+()]+$/.test(value) || value.replace(/\D/g, '').length < 10) {
+                    return { valid: false, error: `${paramName} must be a valid phone number` };
+                }
+                break;
+            case 'number':
+                if (isNaN(Number(value))) {
+                    return { valid: false, error: `${paramName} must be a number` };
+                }
+                break;
+            case 'date':
+                if (isNaN(Date.parse(value))) {
+                    return { valid: false, error: `${paramName} must be a valid date` };
+                }
+                break;
+        }
+    }
+    // Regex validation
+    if (definition.validation) {
+        const regex = new RegExp(definition.validation);
+        if (!regex.test(value)) {
+            return { valid: false, error: `${paramName} format is invalid` };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Check if all required parameters have been collected
+ */
+export function areAllParametersCollected(api, providedParams) {
+    if (!api.requiredParameters || api.requiredParameters.length === 0) {
+        return true;
+    }
+    return !api.requiredParameters.some(param => param.required !== false && !providedParams[param.name]);
+}
+/**
+ * Collect parameters interactively
+ * Returns a system prompt asking for the next missing parameter
+ * OR triggers API call if all parameters are collected
+ */
+export function generateParameterPromptOrCallAPI(api, providedParams, intent, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Check if all required parameters are collected
+        const allCollected = areAllParametersCollected(api, providedParams);
+        if (allCollected) {
+            // All parameters are collected - call the API
+            try {
+                const apiResponse = yield callAPI({
+                    apiId: api.id,
+                    parameters: providedParams,
+                    context
+                }, api);
+                return {
+                    apiResponse,
+                    allParametersCollected: true
+                };
+            }
+            catch (error) {
+                return {
+                    prompt: `Error executing request: ${error.message}`,
+                    allParametersCollected: true
+                };
+            }
+        }
+        // Still missing parameters - ask for the next one
+        const nextParam = getNextMissingParameter(api, providedParams);
+        if (!nextParam) {
+            return {
+                allParametersCollected: true
+            };
+        }
+        const provided = Object.keys(providedParams)
+            .filter(key => providedParams[key])
+            .map(key => `- ${key}: ${providedParams[key]}`)
+            .join('\n');
+        let prompt = `To complete your request to ${intent}, I need the following information:\n\n`;
+        prompt += `**${nextParam.parameter}**: ${nextParam.description}`;
+        if (nextParam.type) {
+            prompt += ` (Type: ${nextParam.type})`;
+        }
+        if (nextParam.example) {
+            prompt += `\nExample: ${nextParam.example}`;
+        }
+        if (provided) {
+            prompt += `\n\nAlready provided:\n${provided}`;
+        }
+        return {
+            prompt,
+            allParametersCollected: false
+        };
+    });
+}
+/**
+ * Collect parameters interactively
+ * Returns a system prompt asking for the next missing parameter
+ */
+export function generateParameterPrompt(api, providedParams) {
+    const nextParam = getNextMissingParameter(api, providedParams);
+    if (!nextParam) {
+        return '';
+    }
+    const provided = Object.keys(providedParams)
+        .filter(key => providedParams[key])
+        .map(key => `- ${key}: ${providedParams[key]}`)
+        .join('\n');
+    let prompt = `To complete your request, I need the following information:\n\n`;
+    prompt += `**${nextParam.parameter}**: ${nextParam.description}`;
+    if (nextParam.type) {
+        prompt += ` (Type: ${nextParam.type})`;
+    }
+    if (nextParam.example) {
+        prompt += `\nExample: ${nextParam.example}`;
+    }
+    if (provided) {
+        prompt += `\n\nAlready provided:\n${provided}`;
+    }
+    return prompt;
+}

package/dist/services/integrations.d.ts

@@ -0,0 +1,62 @@
+/**
+ * API Integration Examples
+ *
+ * This file provides examples of how to create and configure API integrations
+ * for use with the Copilot chat widget.
+ */
+import type { APIIntegration } from '../types/copilot';
+/**
+ * Example: Customer Creation API with Required Parameters
+ *
+ * This example shows how to integrate an API that creates a customer
+ * with interactive parameter collection
+ */
+export declare const createCustomerAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: REST API Integration
+ *
+ * This example shows how to integrate a generic REST API that returns user data
+ */
+export declare const createUserAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: Data Analysis API Integration
+ *
+ * This shows how to integrate an API that performs data analysis
+ */
+export declare const createAnalysisAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: Search API Integration
+ *
+ * Shows how to integrate a search/query API
+ */
+export declare const createSearchAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: Webhook/Action API Integration
+ *
+ * Shows how to integrate APIs that perform actions (create, update, delete)
+ */
+export declare const createActionAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: Database Query Integration
+ *
+ * Shows how to integrate a database query service
+ */
+export declare const createDatabaseAPIIntegration: (baseUrl: string) => APIIntegration;
+/**
+ * Example: External Service Integration (Weather, News, etc.)
+ */
+export declare const createWeatherAPIIntegration: (apiKey: string) => APIIntegration;
+/**
+ * Helper function to create a custom API integration
+ */
+export declare function createCustomAPIIntegration(config: {
+    id: string;
+    name: string;
+    endpoint: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    intents?: string[];
+    headers?: Record<string, string>;
+    buildRequest: (params: Record<string, any>, context?: Record<string, any>) => any;
+    formatResponse: (data: any) => string;
+    shouldCall?: (intent: string, parameters: Record<string, any>) => boolean;
+}): APIIntegration;