floating-copilot-widget 1.4.3 → 1.5.1

package/dist/index.js

@@ -261,6 +261,835 @@ const FloatingCopilot = ({ config = {} }) => {
         finalConfig.resizable && !isMaximized && (React.createElement("div", { className: "copilot-resize-handle", onMouseDown: handleMouseDownResize, title: "Drag to resize" }))));
 };
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 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.
+ */
+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
+ */
+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);
+        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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+}
+
+/**
+ * API Integration Examples
+ *
+ * This file provides examples of how to create and configure API integrations
+ * for use with the Copilot chat widget.
+ */
+/**
+ * Example: Customer Creation API with Required Parameters
+ *
+ * This example shows how to integrate an API that creates a customer
+ * with interactive parameter collection
+ */
+const createCustomerAPIIntegration = (baseUrl) => {
+    const requiredParams = [
+        {
+            name: 'name',
+            description: 'Customer full name',
+            type: 'string',
+            required: true,
+            example: 'John Doe'
+        },
+        {
+            name: 'email',
+            description: 'Customer email address',
+            type: 'email',
+            required: true,
+            validation: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
+            example: 'john@example.com'
+        },
+        {
+            name: 'phone',
+            description: 'Customer phone number',
+            type: 'phone',
+            required: true,
+            example: '+1-555-123-4567'
+        },
+        {
+            name: 'company',
+            description: 'Company name (optional)',
+            type: 'string',
+            required: false,
+            example: 'Acme Corp'
+        }
+    ];
+    return {
+        id: 'create_customer',
+        name: 'Create Customer',
+        endpoint: `${baseUrl}/api/customers`,
+        method: 'POST',
+        intents: ['create_customer', 'add_customer', 'new_customer'],
+        requiredParameters: requiredParams,
+        buildRequest: (params) => ({
+            name: params.name,
+            email: params.email,
+            phone: params.phone,
+            company: params.company || null,
+            createdAt: new Date().toISOString()
+        }),
+        formatResponse: (data) => {
+            return `✅ **Customer Created Successfully**\n\n` +
+                `**ID**: ${data.id}\n` +
+                `**Name**: ${data.name}\n` +
+                `**Email**: ${data.email}\n` +
+                `**Phone**: ${data.phone}\n` +
+                (data.company ? `**Company**: ${data.company}\n` : '') +
+                `**Created**: ${new Date(data.createdAt).toLocaleDateString()}`;
+        },
+        shouldCall: (intent, params) => {
+            // Call when all required params are present
+            return !!(params.name && params.email && params.phone);
+        }
+    };
+};
+/**
+ * Example: REST API Integration
+ *
+ * This example shows how to integrate a generic REST API that returns user data
+ */
+const createUserAPIIntegration = (baseUrl) => ({
+    id: 'user_api',
+    name: 'User Service API',
+    endpoint: `${baseUrl}/api/users`,
+    method: 'GET',
+    intents: ['get_user', 'find_user', 'lookup_user'],
+    buildRequest: (params) => {
+        // Transform intent parameters into API query string
+        const queryParams = new URLSearchParams();
+        if (params.userId)
+            queryParams.append('id', params.userId);
+        if (params.username)
+            queryParams.append('username', params.username);
+        if (params.email)
+            queryParams.append('email', params.email);
+        return queryParams.toString();
+    },
+    formatResponse: (data) => {
+        if (Array.isArray(data)) {
+            return data.map(user => `**${user.name}** (${user.email})\nID: ${user.id}\nRole: ${user.role}`).join('\n\n');
+        }
+        return `**${data.name}** (${data.email})\nID: ${data.id}\nRole: ${data.role}`;
+    },
+    shouldCall: (intent, params) => {
+        // Only call if we have identifying parameters
+        return !!(params.userId || params.username || params.email);
+    }
+});
+/**
+ * Example: Data Analysis API Integration
+ *
+ * This shows how to integrate an API that performs data analysis
+ */
+const createAnalysisAPIIntegration = (baseUrl) => ({
+    id: 'analysis_api',
+    name: 'Data Analysis Service',
+    endpoint: `${baseUrl}/api/analysis`,
+    method: 'POST',
+    intents: ['analyze_data', 'generate_report', 'data_insights'],
+    buildRequest: (params) => ({
+        dataSource: params.dataSource,
+        analysisType: params.analysisType || 'summary',
+        timeRange: params.timeRange,
+        filters: params.filters || {}
+    }),
+    formatResponse: (data) => {
+        let response = `## Analysis Results\n\n`;
+        if (data.summary) {
+            response += `### Summary\n${data.summary}\n\n`;
+        }
+        if (data.metrics) {
+            response += `### Key Metrics\n`;
+            Object.entries(data.metrics).forEach(([key, value]) => {
+                response += `- **${key}**: ${value}\n`;
+            });
+            response += '\n';
+        }
+        if (data.recommendations) {
+            response += `### Recommendations\n`;
+            data.recommendations.forEach((rec) => {
+                response += `- ${rec}\n`;
+            });
+        }
+        return response;
+    },
+    shouldCall: (intent, params) => {
+        return !!(params.dataSource && params.analysisType);
+    }
+});
+/**
+ * Example: Search API Integration
+ *
+ * Shows how to integrate a search/query API
+ */
+const createSearchAPIIntegration = (baseUrl) => ({
+    id: 'search_api',
+    name: 'Search Service',
+    endpoint: `${baseUrl}/api/search`,
+    method: 'POST',
+    intents: ['search', 'find', 'query'],
+    buildRequest: (params) => ({
+        query: params.query,
+        filters: {
+            type: params.type,
+            category: params.category,
+            dateRange: params.dateRange
+        },
+        limit: params.limit || 10,
+        offset: params.offset || 0
+    }),
+    formatResponse: (data) => {
+        if (!data.results || data.results.length === 0) {
+            return 'No results found matching your search criteria.';
+        }
+        let response = `Found **${data.results.length}** results:\n\n`;
+        response += data.results.map((result, index) => `${index + 1}. **${result.title}**\n   ${result.description}\n   URL: ${result.url}`).join('\n\n');
+        return response;
+    }
+});
+/**
+ * Example: Webhook/Action API Integration
+ *
+ * Shows how to integrate APIs that perform actions (create, update, delete)
+ */
+const createActionAPIIntegration = (baseUrl) => ({
+    id: 'action_api',
+    name: 'Action Service',
+    endpoint: `${baseUrl}/api/actions`,
+    method: 'POST',
+    intents: ['create', 'update', 'delete', 'perform_action'],
+    buildRequest: (params) => ({
+        action: params.action,
+        targetId: params.targetId,
+        targetType: params.targetType,
+        payload: params.payload || {},
+        metadata: params.metadata || {}
+    }),
+    formatResponse: (data) => {
+        if (data.success) {
+            return `✅ **Action Completed Successfully**\n\n${data.message || 'The requested action has been performed.'}\n\nDetails: ${JSON.stringify(data.result, null, 2)}`;
+        }
+        return `❌ **Action Failed**\n\n${data.message || 'The requested action could not be completed.'}`;
+    }
+});
+/**
+ * Example: Database Query Integration
+ *
+ * Shows how to integrate a database query service
+ */
+const createDatabaseAPIIntegration = (baseUrl) => ({
+    id: 'database_api',
+    name: 'Database Query Service',
+    endpoint: `${baseUrl}/api/query`,
+    method: 'POST',
+    intents: ['query_database', 'get_data', 'fetch_records'],
+    buildRequest: (params) => ({
+        table: params.table,
+        columns: params.columns || ['*'],
+        where: params.where || {},
+        orderBy: params.orderBy,
+        limit: params.limit || 50
+    }),
+    formatResponse: (data) => {
+        if (!data.rows || data.rows.length === 0) {
+            return 'No records found matching your query.';
+        }
+        let response = `Retrieved **${data.rows.length}** records:\n\n`;
+        // Format as table if we have column information
+        if (data.columns && data.columns.length > 0) {
+            response += `| ${data.columns.join(' | ')} |\n`;
+            response += `|${data.columns.map(() => '-').join('|')}|\n`;
+            data.rows.forEach((row) => {
+                response += `| ${data.columns.map((col) => row[col] || '-').join(' | ')} |\n`;
+            });
+        }
+        else {
+            // Fallback: display as JSON
+            response += '```json\n' + JSON.stringify(data.rows, null, 2) + '\n```';
+        }
+        return response;
+    }
+});
+/**
+ * Example: External Service Integration (Weather, News, etc.)
+ */
+const createWeatherAPIIntegration = (apiKey) => ({
+    id: 'weather_api',
+    name: 'Weather Service',
+    endpoint: 'https://api.openweathermap.org/data/2.5/weather',
+    method: 'GET',
+    headers: {
+        'User-Agent': 'FloatingCopilot/1.0'
+    },
+    intents: ['get_weather', 'weather', 'check_weather'],
+    buildRequest: (params) => {
+        // Note: For actual use, pass apiKey securely
+        return {
+            q: params.city,
+            appid: apiKey,
+            units: params.units || 'metric'
+        };
+    },
+    formatResponse: (data) => {
+        var _a, _b, _c;
+        const weather = (_a = data.weather) === null || _a === void 0 ? void 0 : _a[0];
+        const main = data.main;
+        return `**Weather for ${data.name}, ${(_b = data.sys) === null || _b === void 0 ? void 0 : _b.country}**
+
+Current: ${weather === null || weather === void 0 ? void 0 : weather.main} (${weather === null || weather === void 0 ? void 0 : weather.description})
+Temperature: ${main === null || main === void 0 ? void 0 : main.temp}°C
+Feels like: ${main === null || main === void 0 ? void 0 : main.feels_like}°C
+Humidity: ${main === null || main === void 0 ? void 0 : main.humidity}%
+Wind Speed: ${(_c = data.wind) === null || _c === void 0 ? void 0 : _c.speed} m/s
+
+Updated: ${new Date(data.dt * 1000).toLocaleString()}`;
+    }
+});
+/**
+ * Helper function to create a custom API integration
+ */
+function createCustomAPIIntegration(config) {
+    return config;
+}
+
 exports.FloatingCopilot = FloatingCopilot;
+exports.analyzeUserIntent = analyzeUserIntent;
+exports.areAllParametersCollected = areAllParametersCollected;
+exports.callAPI = callAPI;
+exports.createActionAPIIntegration = createActionAPIIntegration;
+exports.createAnalysisAPIIntegration = createAnalysisAPIIntegration;
+exports.createCustomAPIIntegration = createCustomAPIIntegration;
+exports.createCustomerAPIIntegration = createCustomerAPIIntegration;
+exports.createDatabaseAPIIntegration = createDatabaseAPIIntegration;
+exports.createSearchAPIIntegration = createSearchAPIIntegration;
+exports.createUserAPIIntegration = createUserAPIIntegration;
+exports.createWeatherAPIIntegration = createWeatherAPIIntegration;
 exports.default = FloatingCopilot;
 exports.defaultConfig = defaultConfig;
+exports.generateCopilotResponse = generateCopilotResponse;
+exports.generateParameterPrompt = generateParameterPrompt;
+exports.generateParameterPromptOrCallAPI = generateParameterPromptOrCallAPI;
+exports.getMissingParameters = getMissingParameters;
+exports.getNextMissingParameter = getNextMissingParameter;
+exports.mergeAPIIntegrations = mergeAPIIntegrations;
+exports.processUserMessage = processUserMessage;
+exports.validateAPIIntegration = validateAPIIntegration;
+exports.validateGithubToken = validateGithubToken;
+exports.validateParameter = validateParameter;