@nxuss/lemma 1.17.0 → 1.18.1

package/sdks/crewai/dist/index.d.ts

@@ -1,130 +0,0 @@
-/**
- * Lemma Crew Configuration
- */
-export interface LemmaCrewConfig {
-    /** WebSocket URL of the Lemma router */
-    routerUrl: string;
-    /** Agent ID */
-    agentId: string;
-    /** Agent role (CrewAI concept) */
-    role: string;
-    /** Agent goal */
-    goal: string;
-    /** Agent backstory */
-    backstory?: string;
-    /** Capabilities this agent provides */
-    capabilities?: string[];
-    /** Enable verbose logging */
-    verbose?: boolean;
-    /** Allow task delegation */
-    allowDelegation?: boolean;
-}
-/**
- * Task execution request
- */
-export interface TaskRequest {
-    description: string;
-    expectedOutput?: string;
-    context?: any;
-    allowDelegation?: boolean;
-}
-/**
- * Task execution result
- */
-export interface TaskResult {
-    success: boolean;
-    output?: string;
-    error?: string;
-    executionTime: number;
-    cached?: boolean;
-    similarity?: number;
-}
-/**
- * CrewAI Agent integrated with Lemma Router
- */
-export declare class LemmaCrewAgent {
-    private ws;
-    private config;
-    private connected;
-    private pendingTasks;
-    constructor(config: LemmaCrewConfig);
-    /**
-     * Connect to Lemma router
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from router
-     */
-    disconnect(): void;
-    /**
-     * Execute a task
-     */
-    execute(task: TaskRequest): Promise<TaskResult>;
-    /**
-     * Handle incoming message from router
-     */
-    private handleMessage;
-    /**
-     * Handle task assignment from router
-     */
-    private handleTaskAssign;
-    /**
-     * Handle task response from router
-     */
-    private handleTaskResponse;
-    /**
-     * Perform task (override in subclasses)
-     */
-    protected performTask(description: string, parameters: any): Promise<string>;
-    /**
-     * Send message to router
-     */
-    private send;
-    /**
-     * Log message if verbose
-     */
-    private log;
-    /**
-     * Get agent info
-     */
-    getInfo(): {
-        agentId: string;
-        role: string;
-        goal: string;
-        backstory: string;
-        capabilities: string[];
-    };
-}
-/**
- * Lemma Crew - Multi-agent orchestration
- */
-export interface LemmaCrewOptions {
-    routerUrl: string;
-    agents: Omit<LemmaCrewConfig, 'routerUrl'>[];
-    verbose?: boolean;
-}
-export declare class LemmaCrew {
-    private agents;
-    private config;
-    constructor(config: LemmaCrewOptions);
-    /**
-     * Connect all agents
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect all agents
-     */
-    disconnect(): void;
-    /**
-     * Execute a multi-agent workflow
-     */
-    kickoff(options: {
-        task: string;
-        process?: 'sequential' | 'hierarchical';
-    }): Promise<any>;
-    /**
-     * Get all agents
-     */
-    getAgents(): LemmaCrewAgent[];
-}
-export default LemmaCrewAgent;

package/sdks/crewai/dist/index.js

@@ -1,308 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LemmaCrew = exports.LemmaCrewAgent = void 0;
-const ws_1 = __importDefault(require("ws"));
-const uuid_1 = require("uuid");
-/**
- * CrewAI Agent integrated with Lemma Router
- */
-class LemmaCrewAgent {
-    constructor(config) {
-        this.ws = null;
-        this.connected = false;
-        this.pendingTasks = new Map();
-        this.config = {
-            routerUrl: config.routerUrl,
-            agentId: config.agentId,
-            role: config.role,
-            goal: config.goal,
-            backstory: config.backstory || '',
-            capabilities: config.capabilities || ['crewai'],
-            verbose: config.verbose || false,
-            allowDelegation: config.allowDelegation !== false,
-        };
-    }
-    /**
-     * Connect to Lemma router
-     */
-    async connect() {
-        return new Promise((resolve, reject) => {
-            this.ws = new ws_1.default(this.config.routerUrl);
-            this.ws.on('open', () => {
-                this.log('Connected to Lemma router');
-                // Send handshake
-                this.send({
-                    type: 'HANDSHAKE',
-                    messageId: (0, uuid_1.v4)(),
-                    timestamp: Date.now(),
-                    payload: {
-                        agentId: this.config.agentId,
-                        agentName: `${this.config.role} (CrewAI)`,
-                        version: '1.0.0',
-                        capabilities: this.config.capabilities.map(name => ({
-                            name,
-                            version: '1.0.0',
-                        })),
-                        metadata: {
-                            role: this.config.role,
-                            goal: this.config.goal,
-                            backstory: this.config.backstory,
-                            framework: 'crewai',
-                        },
-                    },
-                });
-            });
-            this.ws.on('message', (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    this.handleMessage(message);
-                    if (message.type === 'HANDSHAKE_ACK') {
-                        this.connected = true;
-                        this.log('Handshake acknowledged');
-                        resolve();
-                    }
-                }
-                catch (error) {
-                    console.error('Error parsing message:', error);
-                }
-            });
-            this.ws.on('error', (error) => {
-                console.error('WebSocket error:', error);
-                if (!this.connected) {
-                    reject(error);
-                }
-            });
-            this.ws.on('close', () => {
-                this.connected = false;
-                this.log('Disconnected from router');
-            });
-            // Connection timeout
-            setTimeout(() => {
-                if (!this.connected) {
-                    reject(new Error('Connection timeout'));
-                }
-            }, 10000);
-        });
-    }
-    /**
-     * Disconnect from router
-     */
-    disconnect() {
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-            this.connected = false;
-        }
-    }
-    /**
-     * Execute a task
-     */
-    async execute(task) {
-        if (!this.connected) {
-            throw new Error('Not connected to router. Call connect() first.');
-        }
-        const taskId = (0, uuid_1.v4)();
-        this.log(`Executing task: ${task.description}`);
-        return new Promise((resolve, reject) => {
-            this.pendingTasks.set(taskId, { resolve, reject });
-            // Send task request to router
-            this.send({
-                type: 'TASK_REQUEST',
-                messageId: (0, uuid_1.v4)(),
-                timestamp: Date.now(),
-                payload: {
-                    taskId,
-                    description: task.description,
-                    requiredCapabilities: this.config.capabilities,
-                    parameters: {
-                        expectedOutput: task.expectedOutput,
-                        context: task.context,
-                        allowDelegation: task.allowDelegation ?? this.config.allowDelegation,
-                    },
-                },
-            });
-        });
-    }
-    /**
-     * Handle incoming message from router
-     */
-    handleMessage(message) {
-        switch (message.type) {
-            case 'TASK_ASSIGN':
-                this.handleTaskAssign(message);
-                break;
-            case 'TASK_RESPONSE':
-                this.handleTaskResponse(message);
-                break;
-            case 'PING':
-                this.send({
-                    type: 'PONG',
-                    messageId: (0, uuid_1.v4)(),
-                    timestamp: Date.now(),
-                    payload: {
-                        originalMessageId: message.messageId,
-                    },
-                });
-                break;
-        }
-    }
-    /**
-     * Handle task assignment from router
-     */
-    async handleTaskAssign(message) {
-        const { taskId, description, parameters } = message.payload;
-        const startTime = Date.now();
-        this.log(`Received task assignment: ${description}`);
-        try {
-            // Execute the task (override this method in subclasses)
-            const output = await this.performTask(description, parameters);
-            // Send response back to router
-            this.send({
-                type: 'TASK_RESPONSE',
-                messageId: (0, uuid_1.v4)(),
-                timestamp: Date.now(),
-                payload: {
-                    taskId,
-                    success: true,
-                    result: output,
-                    executionTime: Date.now() - startTime,
-                    taskDescription: description,
-                },
-            });
-        }
-        catch (error) {
-            this.send({
-                type: 'TASK_RESPONSE',
-                messageId: (0, uuid_1.v4)(),
-                timestamp: Date.now(),
-                payload: {
-                    taskId,
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    executionTime: Date.now() - startTime,
-                },
-            });
-        }
-    }
-    /**
-     * Handle task response from router
-     */
-    handleTaskResponse(message) {
-        const { taskId, success, result, error, executionTime, cached, similarity } = message.payload;
-        const pending = this.pendingTasks.get(taskId);
-        if (!pending) {
-            return;
-        }
-        this.pendingTasks.delete(taskId);
-        if (success) {
-            this.log(`Task completed in ${executionTime}ms${cached ? ' (cached)' : ''}`);
-            pending.resolve({
-                success: true,
-                output: result,
-                executionTime,
-                cached,
-                similarity,
-            });
-        }
-        else {
-            pending.reject(new Error(error || 'Task failed'));
-        }
-    }
-    /**
-     * Perform task (override in subclasses)
-     */
-    async performTask(description, parameters) {
-        // Default implementation - subclasses should override
-        return `Task completed: ${description}`;
-    }
-    /**
-     * Send message to router
-     */
-    send(message) {
-        if (!this.ws || !this.connected) {
-            throw new Error('Not connected to router');
-        }
-        this.ws.send(JSON.stringify(message));
-    }
-    /**
-     * Log message if verbose
-     */
-    log(message) {
-        if (this.config.verbose) {
-            console.log(`[${this.config.role}] ${message}`);
-        }
-    }
-    /**
-     * Get agent info
-     */
-    getInfo() {
-        return {
-            agentId: this.config.agentId,
-            role: this.config.role,
-            goal: this.config.goal,
-            backstory: this.config.backstory,
-            capabilities: this.config.capabilities,
-        };
-    }
-}
-exports.LemmaCrewAgent = LemmaCrewAgent;
-class LemmaCrew {
-    constructor(config) {
-        this.agents = [];
-        this.config = config;
-        // Create agents
-        this.agents = config.agents.map(agentConfig => new LemmaCrewAgent({
-            ...agentConfig,
-            routerUrl: config.routerUrl,
-            verbose: config.verbose,
-        }));
-    }
-    /**
-     * Connect all agents
-     */
-    async connect() {
-        await Promise.all(this.agents.map(agent => agent.connect()));
-    }
-    /**
-     * Disconnect all agents
-     */
-    disconnect() {
-        this.agents.forEach(agent => agent.disconnect());
-    }
-    /**
-     * Execute a multi-agent workflow
-     */
-    async kickoff(options) {
-        const { task, process = 'sequential' } = options;
-        if (process === 'sequential') {
-            // Execute tasks sequentially through agents
-            let result = task;
-            for (const agent of this.agents) {
-                const taskResult = await agent.execute({
-                    description: result,
-                });
-                result = taskResult.output || result;
-            }
-            return result;
-        }
-        else {
-            // Hierarchical - first agent coordinates others
-            const manager = this.agents[0];
-            return await manager.execute({
-                description: task,
-                allowDelegation: true,
-            });
-        }
-    }
-    /**
-     * Get all agents
-     */
-    getAgents() {
-        return this.agents;
-    }
-}
-exports.LemmaCrew = LemmaCrew;
-exports.default = LemmaCrewAgent;