@nxuss/lemma 1.7.0 → 1.7.1

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

@@ -0,0 +1,130 @@
+/**
+ * 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

@@ -0,0 +1,308 @@
+"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;