@props-labs/mesh-os 0.1.7

package/dist/core/client.js

@@ -0,0 +1,581 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshOS = exports.InvalidSlugError = exports.GraphQLError = void 0;
+/**
+ * Core functionality for MeshOS.
+ */
+const openai_1 = __importDefault(require("openai"));
+const chalk_1 = __importDefault(require("chalk"));
+const boxen_1 = __importDefault(require("boxen"));
+const taxonomy_1 = require("./taxonomy");
+// Constants
+const MIN_THRESHOLD = 0.3;
+const SLUG_PATTERN = /^[a-z][a-z0-9_-]*[a-z0-9]$/;
+/**
+ * GraphQL error class.
+ */
+class GraphQLError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GraphQLError';
+    }
+}
+exports.GraphQLError = GraphQLError;
+/**
+ * Invalid slug error class.
+ */
+class InvalidSlugError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidSlugError';
+    }
+}
+exports.InvalidSlugError = InvalidSlugError;
+/**
+ * MeshOS client for interacting with the system.
+ */
+class MeshOS {
+    constructor(config = {}) {
+        this.url = `${config.url || 'http://localhost:8080'}/v1/graphql`;
+        this.headers = {
+            'Content-Type': 'application/json',
+            'x-hasura-admin-secret': config.apiKey || 'meshos'
+        };
+        // Set up OpenAI
+        const openaiApiKey = config.openaiApiKey || process.env.OPENAI_API_KEY;
+        if (!openaiApiKey) {
+            const boxOptions = {
+                title: 'Missing API Key',
+                titleAlignment: 'center',
+                padding: 1,
+                borderColor: 'yellow',
+                borderStyle: 'round'
+            };
+            console.error((0, boxen_1.default)(chalk_1.default.yellow('⚠️  OpenAI API key not found!\n\n') +
+                'Please set your OpenAI API key in the environment:\n' +
+                chalk_1.default.green('OPENAI_API_KEY=your-key-here') + '\n\n' +
+                'You can get an API key at: ' + chalk_1.default.blue('https://platform.openai.com/api-keys'), boxOptions));
+            throw new Error('OpenAI API key is required');
+        }
+        this.openai = new openai_1.default({ apiKey: openaiApiKey });
+    }
+    validateSlug(slug) {
+        return SLUG_PATTERN.test(slug);
+    }
+    /**
+     * Execute a GraphQL query.
+     */
+    async executeQuery(query, variables) {
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify({
+                query,
+                variables: variables || {}
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        if (result.errors) {
+            throw new GraphQLError(result.errors[0].message);
+        }
+        return result.data;
+    }
+    /**
+     * Create an embedding for the given text.
+     */
+    async createEmbedding(text) {
+        const response = await this.openai.embeddings.create({
+            model: 'text-embedding-3-small',
+            input: text
+        });
+        return response.data[0].embedding;
+    }
+    /**
+     * Register a new agent in the system.
+     */
+    async registerAgent(name, description, metadata, slug) {
+        if (slug && !this.validateSlug(slug)) {
+            throw new InvalidSlugError("Slug must start with a letter and contain only lowercase letters, " +
+                "numbers, hyphens, and underscores");
+        }
+        // First check if agent with slug exists
+        if (slug) {
+            const existing = await this.getAgentBySlug(slug);
+            if (existing) {
+                return existing;
+            }
+        }
+        const query = `
+      mutation RegisterAgent($name: String!, $description: String!, $metadata: jsonb, $slug: String) {
+        insert_agents_one(object: {
+          name: $name,
+          description: $description,
+          metadata: $metadata,
+          status: "active",
+          slug: $slug
+        }) {
+          id
+          name
+          description
+          metadata
+          status
+          slug
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            name,
+            description,
+            metadata: metadata || {},
+            slug
+        });
+        return result.insert_agents_one;
+    }
+    /**
+     * Get agent details by slug.
+     */
+    async getAgentBySlug(slug) {
+        if (!this.validateSlug(slug)) {
+            throw new InvalidSlugError("Slug must start with a letter and contain only lowercase letters, " +
+                "numbers, hyphens, and underscores");
+        }
+        const query = `
+      query GetAgentBySlug($slug: String!) {
+        agents(where: {slug: {_eq: $slug}}, limit: 1) {
+          id
+          name
+          description
+          metadata
+          status
+          slug
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { slug });
+        return result.agents[0] || null;
+    }
+    /**
+     * Unregister an agent and remove all their memories.
+     */
+    async unregisterAgent(agentId) {
+        const query = `
+      mutation UnregisterAgent($id: uuid!) {
+        delete_agents_by_pk(id: $id) {
+          id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: agentId
+        });
+        return result.delete_agents_by_pk !== null;
+    }
+    /**
+     * Get agent details by ID.
+     */
+    async getAgent(agentId) {
+        const query = `
+      query GetAgent($id: uuid!) {
+        agents_by_pk(id: $id) {
+          id
+          name
+          description
+          metadata
+          status
+          slug
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: agentId
+        });
+        return result.agents_by_pk;
+    }
+    /**
+     * Store a new memory.
+     */
+    async remember(content, agentId, metadata) {
+        // Create default metadata if none provided
+        const fullMetadata = taxonomy_1.memoryMetadataSchema.parse({
+            type: taxonomy_1.DataType.KNOWLEDGE,
+            subtype: taxonomy_1.KnowledgeSubtype.DATASET,
+            tags: [],
+            version: 1,
+            history: [],
+            additional: {},
+            ...metadata
+        });
+        // Create embedding
+        const embedding = await this.createEmbedding(content);
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const query = `
+      mutation Remember($content: String!, $agentId: uuid!, $metadata: jsonb!, $embedding: vector!) {
+        insert_memories_one(object: {
+          content: $content,
+          agent_id: $agentId,
+          metadata: $metadata,
+          embedding: $embedding
+        }) {
+          id
+          agent_id
+          content
+          metadata
+          embedding
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            content,
+            agentId,
+            metadata: fullMetadata,
+            embedding: embeddingStr
+        });
+        // Convert snake_case to camelCase
+        const { agent_id, created_at, updated_at, ...rest } = result.insert_memories_one;
+        return {
+            ...rest,
+            agentId: agent_id,
+            createdAt: created_at,
+            updatedAt: updated_at,
+        };
+    }
+    /**
+     * Delete a specific memory.
+     */
+    async forget(memoryId) {
+        const query = `
+      mutation Forget($id: uuid!) {
+        delete_memories_by_pk(id: $id) {
+          id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: memoryId
+        });
+        return result.delete_memories_by_pk !== null;
+    }
+    /**
+     * Create a link between two memories.
+     */
+    async linkMemories(sourceMemoryId, targetMemoryId, relationship, weight = 1.0, metadata) {
+        const query = `
+      mutation LinkMemories(
+        $sourceMemory: uuid!,
+        $targetMemory: uuid!,
+        $relationship: String!,
+        $weight: float8!,
+        $metadata: jsonb!
+      ) {
+        insert_memory_edges_one(object: {
+          source_memory: $sourceMemory,
+          target_memory: $targetMemory,
+          relationship: $relationship,
+          weight: $weight,
+          metadata: $metadata
+        }) {
+          id
+          source_memory
+          target_memory
+          relationship
+          weight
+          created_at
+          metadata
+        }
+      }
+    `;
+        const fullMetadata = {
+            relationship,
+            weight,
+            bidirectional: false,
+            additional: {},
+            ...metadata
+        };
+        const result = await this.executeQuery(query, {
+            sourceMemory: sourceMemoryId,
+            targetMemory: targetMemoryId,
+            relationship,
+            weight,
+            metadata: fullMetadata
+        });
+        // Convert snake_case to camelCase
+        const { source_memory, target_memory, created_at, ...rest } = result.insert_memory_edges_one;
+        return {
+            ...rest,
+            sourceMemory: source_memory,
+            targetMemory: target_memory,
+            createdAt: created_at,
+        };
+    }
+    /**
+     * Remove links between two memories.
+     */
+    async unlinkMemories(sourceMemoryId, targetMemoryId, relationship) {
+        const conditions = {
+            source_memory: { _eq: sourceMemoryId },
+            target_memory: { _eq: targetMemoryId }
+        };
+        if (relationship) {
+            conditions.relationship = { _eq: relationship };
+        }
+        const query = `
+      mutation UnlinkMemories($where: memory_edges_bool_exp!) {
+        delete_memory_edges(where: $where) {
+          affected_rows
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            where: conditions
+        });
+        return result.delete_memory_edges.affected_rows > 0;
+    }
+    /**
+     * Update a memory and optionally create a version edge to the previous version.
+     */
+    async updateMemory(memoryId, content, metadata, createVersionEdge = true) {
+        // First get the current memory
+        const query = `
+      query GetMemory($id: uuid!) {
+        memories_by_pk(id: $id) {
+          id
+          agent_id
+          content
+          metadata
+          embedding
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: memoryId
+        });
+        const oldMemory = result.memories_by_pk;
+        if (!oldMemory) {
+            throw new Error(`Memory ${memoryId} not found`);
+        }
+        // Create new memory with updated content and metadata
+        const newMemory = await this.remember(content, oldMemory.agent_id, {
+            ...oldMemory.metadata,
+            version: oldMemory.metadata.version + 1,
+            previousVersion: oldMemory.id,
+            ...metadata
+        });
+        // Create version edge if requested
+        if (createVersionEdge) {
+            await this.linkMemories(oldMemory.id, newMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0, {
+                relationship: taxonomy_1.EdgeType.VERSION_OF,
+                weight: 1.0,
+                bidirectional: false,
+                additional: { version_increment: 1 }
+            });
+        }
+        return newMemory;
+    }
+    /**
+     * Get memories connected to the given memory.
+     */
+    async getConnectedMemories(memoryId, relationship, maxDepth = 1) {
+        const query = `
+      query GetConnectedMemories(
+        $memoryId: uuid!,
+        $relationship: String,
+        $maxDepth: Int!
+      ) {
+        get_connected_memories(
+          memory_id: $memoryId,
+          relationship_type: $relationship,
+          max_depth: $maxDepth
+        ) {
+          source_id
+          target_id
+          relationship
+          weight
+          depth
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            memoryId,
+            relationship,
+            maxDepth
+        });
+        return result.get_connected_memories;
+    }
+    /**
+     * Generate semantic variations of the query.
+     */
+    async expandQuery(query, numVariations = 2) {
+        const systemPrompt = `Generate ${numVariations} semantic variations of the query that mean the same thing.\n` +
+            'Focus on different ways to express the same concept.\n' +
+            'Return ONLY the variations, one per line, no numbering or extra text.\n' +
+            'Variations should be concise and natural, similar in length to the original.';
+        const response = await this.openai.chat.completions.create({
+            model: 'gpt-3.5-turbo',
+            messages: [{
+                    role: 'system',
+                    content: systemPrompt
+                }, {
+                    role: 'user',
+                    content: query
+                }],
+            temperature: 0.7
+        });
+        const content = response.choices[0]?.message?.content;
+        if (!content) {
+            return [query];
+        }
+        const result = [query]; // Include original
+        result.push(...content
+            .split('\n')
+            .map(v => v.trim())
+            .filter(Boolean));
+        return result.slice(0, numVariations + 1);
+    }
+    /**
+     * Search memories by semantic similarity.
+     */
+    async recall(options) {
+        const { query, agentId, limit = 5, threshold = 0.7, minResults = 1, adaptiveThreshold = true, useSemanticExpansion = true, filters } = options;
+        // First try: Direct search with initial threshold
+        let results = await this.recallWithThreshold({
+            query,
+            threshold,
+            agentId,
+            limit,
+            filters
+        });
+        if (results.length >= minResults) {
+            return results.slice(0, limit);
+        }
+        // Second try: Adaptive threshold
+        if (adaptiveThreshold) {
+            let currentThreshold = threshold - 0.05;
+            while (currentThreshold >= MIN_THRESHOLD && results.length < minResults) {
+                const newResults = await this.recallWithThreshold({
+                    query,
+                    threshold: currentThreshold,
+                    agentId,
+                    limit,
+                    filters
+                });
+                // Add new unique results
+                for (const result of newResults) {
+                    if (!results.some(r => r.id === result.id)) {
+                        results.push(result);
+                    }
+                }
+                if (results.length >= minResults)
+                    break;
+                currentThreshold -= 0.05;
+            }
+        }
+        // Third try: Semantic expansion
+        if (results.length === 0 && useSemanticExpansion) {
+            const variations = await this.expandQuery(query);
+            const seenIds = new Map();
+            // Try each variation with original threshold
+            for (const variation of variations.slice(1)) {
+                const variationResults = await this.recallWithThreshold({
+                    query: variation,
+                    threshold,
+                    agentId,
+                    limit,
+                    filters
+                });
+                for (const memory of variationResults) {
+                    const existingMemory = seenIds.get(memory.id);
+                    if (!existingMemory || (memory.similarity || 0) > (existingMemory.similarity || 0)) {
+                        seenIds.set(memory.id, memory);
+                    }
+                }
+                if (seenIds.size >= minResults)
+                    break;
+            }
+            // If still no results, try variations with adaptive threshold
+            if (seenIds.size === 0 && adaptiveThreshold) {
+                let currentThreshold = threshold - 0.05;
+                while (currentThreshold >= MIN_THRESHOLD && seenIds.size === 0) {
+                    for (const variation of variations.slice(1)) {
+                        const variationResults = await this.recallWithThreshold({
+                            query: variation,
+                            threshold: currentThreshold,
+                            agentId,
+                            limit,
+                            filters
+                        });
+                        for (const memory of variationResults) {
+                            const existingMemory = seenIds.get(memory.id);
+                            if (!existingMemory || (memory.similarity || 0) > (existingMemory.similarity || 0)) {
+                                seenIds.set(memory.id, memory);
+                            }
+                        }
+                        if (seenIds.size > 0)
+                            break;
+                    }
+                    if (seenIds.size > 0)
+                        break;
+                    currentThreshold -= 0.05;
+                }
+            }
+            if (seenIds.size > 0) {
+                results = Array.from(seenIds.values());
+            }
+        }
+        // Sort by similarity and return
+        results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
+        return results.slice(0, limit);
+    }
+    /**
+     * Internal method to perform recall with a specific threshold.
+     */
+    async recallWithThreshold(options) {
+        const { query, threshold, agentId, limit = 10, filters } = options;
+        // Create embedding for the query
+        const embedding = await this.createEmbedding(query);
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const gqlQuery = `
+      query SearchMemories($args: search_memories_args!) {
+        search_memories(args: $args) {
+          id
+          agent_id
+          content
+          metadata
+          embedding
+          similarity
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(gqlQuery, {
+            args: {
+                query_embedding: embeddingStr,
+                match_threshold: threshold,
+                match_count: limit,
+                filter_agent_id: agentId,
+                ...filters
+            }
+        });
+        return result.search_memories.map(memory => ({
+            id: memory.id,
+            agentId: memory.agent_id,
+            content: memory.content,
+            metadata: memory.metadata,
+            embedding: memory.embedding,
+            similarity: memory.similarity,
+            createdAt: memory.created_at,
+            updatedAt: memory.updated_at
+        }));
+    }
+}
+exports.MeshOS = MeshOS;