tlnt/dist/core/agentHub.js

TLNT - HMS-Powered Multi-Agent Platform with Government Agency Analysis, Deep Research, and Enterprise-Ready Deployment. Self-optimizing multi-domain AI agent with continuous learning and enterprise-grade performance monitoring.

import { EventEmitter } from 'events';
export class AgentHub extends EventEmitter {
    skills = new Map();
    telemetrySpans = new Map();
    initialized = false;
    constructor() {
        super();
        this.setMaxListeners(100);
    }
    async initialize() {
        if (this.initialized)
            return;
        await this.registerBuiltinSkills();
        this.initialized = true;
        this.emit('initialized');
    }
    async registerBuiltinSkills() {
        this.register({
            name: 'chat',
            description: 'Basic chat functionality using LLM providers',
            version: '1.0.0',
            async run(ctx, args) {
                const { prompt } = args;
                const response = `Echo: ${prompt}\n\nThis is a mock response. In the full implementation, this would use OpenAI, Anthropic, or other LLM providers.`;
                return {
                    success: true,
                    data: response,
                    metadata: {
                        model: 'mock',
                        tokensUsed: prompt.length + response.length,
                    }
                };
            }
        });
        this.register({
            name: 'summarize',
            description: 'Summarize text content',
            version: '1.0.0',
            async run(ctx, args) {
                const { text } = args;
                const summary = `Summary of ${text.length} characters: ${text.slice(0, 100)}...`;
                return {
                    success: true,
                    data: summary,
                    metadata: {
                        originalLength: text.length,
                        summaryLength: summary.length,
                    }
                };
            }
        });
    }
    register(skill) {
        if (this.skills.has(skill.name)) {
            throw new Error(`Skill '${skill.name}' is already registered`);
        }
        this.skills.set(skill.name, skill);
        this.emit('skillRegistered', skill);
    }
    unregister(skillName) {
        const removed = this.skills.delete(skillName);
        if (removed) {
            this.emit('skillUnregistered', skillName);
        }
        return removed;
    }
    listSkills() {
        return Array.from(this.skills.values());
    }
    hasSkill(skillName) {
        return this.skills.has(skillName);
    }
    async execute(skillName, ctx, args) {
        if (!this.initialized) {
            await this.initialize();
        }
        const skill = this.skills.get(skillName);
        if (!skill) {
            return {
                success: false,
                error: new Error(`Skill '${skillName}' not found`),
            };
        }
        const spanId = this.generateSpanId();
        const span = {
            traceId: ctx.sessionId,
            spanId,
            operationName: `skill.${skillName}`,
            startTime: Date.now(),
            tags: {
                skillName,
                skillVersion: skill.version,
                userId: ctx.userId || 'anonymous',
            },
            logs: []
        };
        this.telemetrySpans.set(spanId, span);
        try {
            if (skill.validate && !skill.validate(args)) {
                throw new Error(`Invalid arguments for skill '${skillName}'`);
            }
            this.emit('skillExecutionStarted', { skillName, ctx, args, span });
            const result = await skill.run(ctx, args);
            span.endTime = Date.now();
            result.telemetry = span;
            this.emit('skillExecutionCompleted', { skillName, ctx, args, result, span });
            return result;
        }
        catch (error) {
            span.endTime = Date.now();
            span.logs?.push({
                timestamp: Date.now(),
                level: 'error',
                message: error instanceof Error ? error.message : String(error),
            });
            const errorResult = {
                success: false,
                error: error instanceof Error ? error : new Error(String(error)),
                telemetry: span,
            };
            this.emit('skillExecutionFailed', { skillName, ctx, args, error, span });
            return errorResult;
        }
    }
    getTelemetry(spanId) {
        return this.telemetrySpans.get(spanId);
    }
    getAllTelemetry() {
        return Array.from(this.telemetrySpans.values());
    }
    clearTelemetry() {
        this.telemetrySpans.clear();
    }
    generateSpanId() {
        return Math.random().toString(36).substring(2, 15);
    }
    async healthCheck() {
        return {
            status: 'healthy',
            details: {
                initialized: this.initialized,
                skillCount: this.skills.size,
                telemetrySpanCount: this.telemetrySpans.size,
                uptime: process.uptime(),
            }
        };
    }
}
//# sourceMappingURL=agentHub.js.map