contextual-agent-sdk/dist/core/ContextManager.js

SDK for building AI agents with seamless voice-text context switching

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ContextManager = void 0;
class ContextManager {
    providers = new Map();
    config;
    constructor(config) {
        this.config = {
            maxTokens: 4096,
            defaultFormatter: (ctx) => typeof ctx.content === 'string' ? ctx.content : JSON.stringify(ctx.content),
            errorHandler: (error) => console.error('Context provider error:', error),
            ...config
        };
        this.config.providers.forEach(provider => {
            if (provider.enabled !== false) {
                this.providers.set(provider.id, provider);
            }
        });
    }
    addProvider(provider) {
        this.providers.set(provider.id, provider);
    }
    removeProvider(providerId) {
        this.providers.delete(providerId);
    }
    setProviderEnabled(providerId, enabled) {
        const provider = this.providers.get(providerId);
        if (provider) {
            provider.enabled = enabled;
        }
    }
    async getContext(params = {}) {
        const results = [];
        const contextPromises = Array.from(this.providers.values())
            .filter(provider => provider.enabled !== false)
            .sort((a, b) => (b.priority || 0) - (a.priority || 0))
            .map(async (provider) => {
            try {
                const context = await provider.getContext(params);
                if (context) {
                    results.push({
                        ...context,
                        metadata: {
                            source: provider.id,
                            timestamp: new Date(),
                            tags: [],
                            ...context.metadata,
                            provider: provider.id
                        }
                    });
                }
            }
            catch (error) {
                this.config.errorHandler(error, provider);
            }
        });
        await Promise.all(contextPromises);
        return results;
    }
    formatContext(results) {
        let formattedContext = '';
        for (const result of results) {
            const provider = this.providers.get(result.metadata?.provider || '');
            if (provider?.formatContext) {
                formattedContext += provider.formatContext(result) + '\n\n';
                continue;
            }
            formattedContext += this.config.defaultFormatter(result) + '\n\n';
        }
        return this.truncateIfNeeded(formattedContext);
    }
    truncateIfNeeded(text) {
        const estimatedTokens = Math.ceil(text.length / 4);
        if (estimatedTokens <= this.config.maxTokens)
            return text;
        const ratio = this.config.maxTokens / estimatedTokens;
        const targetLength = Math.floor(text.length * ratio) - 100;
        return text.substring(0, targetLength) + '...';
    }
    getProviders() {
        return Array.from(this.providers.values());
    }
    getProvider(id) {
        return this.providers.get(id);
    }
}
exports.ContextManager = ContextManager;
//# sourceMappingURL=ContextManager.js.map