@props-labs/mesh-os 0.1.17 → 0.1.18

package/dist/core/client.d.ts

@@ -1,4 +1,5 @@
-import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter } from './taxonomy';
+import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter, EntityRelationshipType } from './taxonomy';
+import { EntityManager } from './entities';
 /**
  * An agent in the system.
  */
@@ -56,6 +57,17 @@ export interface MeshOSConfig {
     apiKey?: string;
     openaiApiKey?: string;
 }
+/**
+ * Memory creation options with entity support.
+ */
+export interface RememberOptions {
+    content: string;
+    agentId: string;
+    metadata?: Partial<MemoryMetadata>;
+    expiresAt?: string;
+    entityId?: string;
+    entityRelationship?: EntityRelationshipType;
+}
 /**
  * MeshOS client for interacting with the system.
  */
@@ -63,6 +75,7 @@ export declare class MeshOS {
     private url;
     private headers;
     private openai;
+    entities: EntityManager;
     constructor(config?: MeshOSConfig);
     private validateSlug;
     /**
@@ -90,9 +103,13 @@ export declare class MeshOS {
      */
     getAgent(agentId: string): Promise<Agent | null>;
     /**
-     * Store a new memory.
+     * Store a new memory with optional entity linking.
+     */
+    remember(options: RememberOptions | string, agentId?: string, metadata?: Partial<MemoryMetadata>, expiresAt?: string): Promise<Memory | Memory[]>;
+    /**
+     * Internal method to store a memory.
      */
-    remember(content: string, agentId: string, metadata?: Partial<MemoryMetadata>, expiresAt?: string): Promise<Memory | Memory[]>;
+    private _remember;
     /**
      * Delete a specific memory.
      */
@@ -124,7 +141,7 @@ export declare class MeshOS {
      */
     private expandQuery;
     /**
-     * Search memories by semantic similarity.
+     * Search memories by semantic similarity with optional entity filtering.
      */
     recall(options: {
         query: string;
@@ -137,6 +154,8 @@ export declare class MeshOS {
         filters?: Record<string, unknown>;
         createdAtFilter?: TimestampFilter;
         expiresAtFilter?: TimestampFilter;
+        entityId?: string;
+        entityRelationship?: EntityRelationshipType;
     }): Promise<Memory[]>;
     /**
      * Internal method to perform recall with a specific threshold.

package/dist/core/client.js

@@ -11,6 +11,7 @@ const openai_1 = __importDefault(require("openai"));
 const chalk_1 = __importDefault(require("chalk"));
 const boxen_1 = __importDefault(require("boxen"));
 const taxonomy_1 = require("./taxonomy");
+const entities_1 = require("./entities");
 // Constants
 const SLUG_PATTERN = /^[a-zA-Z0-9_-]+$/;
 /**
@@ -60,6 +61,8 @@ class MeshOS {
             throw new Error('OpenAI API key is required');
         }
         this.openai = new openai_1.default({ apiKey: openaiApiKey });
+        // Initialize entity manager
+        this.entities = new entities_1.EntityManager(this.url, this.headers, this.createEmbedding.bind(this));
     }
     validateSlug(slug) {
         return SLUG_PATTERN.test(slug);
@@ -195,9 +198,32 @@ class MeshOS {
         return result.agents_by_pk;
     }
     /**
-     * Store a new memory.
+     * Store a new memory with optional entity linking.
      */
-    async remember(content, agentId, metadata, expiresAt) {
+    async remember(options, agentId, metadata, expiresAt) {
+        // Handle legacy method signature
+        if (typeof options === 'string') {
+            options = {
+                content: options,
+                agentId: agentId,
+                metadata,
+                expiresAt
+            };
+        }
+        // Create the memory
+        const result = await this._remember(options.content, options.agentId, options.metadata, options.expiresAt);
+        // If entity linking is requested, create the link
+        if (options.entityId) {
+            const memories = Array.isArray(result) ? result : [result];
+            const firstMemory = memories[0];
+            await this.entities.linkMemory(options.entityId, firstMemory.id, options.entityRelationship || taxonomy_1.EntityRelationshipType.ASSOCIATED);
+        }
+        return result;
+    }
+    /**
+     * Internal method to store a memory.
+     */
+    async _remember(content, agentId, metadata, expiresAt) {
         // Create default metadata if none provided
         const fullMetadata = taxonomy_1.memoryMetadataSchema.parse({
             type: taxonomy_1.DataType.KNOWLEDGE,
@@ -528,36 +554,42 @@ class MeshOS {
         return result.slice(0, numVariations + 1);
     }
     /**
-     * Search memories by semantic similarity.
+     * Search memories by semantic similarity with optional entity filtering.
      */
     async recall(options) {
-        const { query, agentId, limit = 5, threshold = 0.7, minResults = 1, adaptiveThreshold = true, useSemanticExpansion = true, filters, createdAtFilter, expiresAtFilter } = options;
-        // First try: Direct search with initial threshold
+        const minResults = options.minResults || 1;
         let results = await this.recallWithThreshold({
-            query,
-            threshold,
-            agentId,
-            limit,
-            filters,
-            createdAtFilter,
-            expiresAtFilter
+            query: options.query,
+            threshold: options.threshold || 0.7,
+            agentId: options.agentId,
+            limit: options.limit,
+            filters: options.filters,
+            createdAtFilter: options.createdAtFilter,
+            expiresAtFilter: options.expiresAtFilter
         });
+        // If entity filtering is requested, filter results
+        if (options.entityId) {
+            const linkedMemories = await this.entities.getLinkedMemories(options.entityId, options.entityRelationship);
+            const linkedMemoryIds = new Set(linkedMemories.map(m => m.id));
+            results = results.filter(memory => linkedMemoryIds.has(memory.id));
+        }
+        // First try: Direct search with initial threshold
         if (results.length >= minResults) {
-            return results.slice(0, limit);
+            return results.slice(0, options.limit || 5);
         }
         // Second try: If adaptive threshold is enabled, try lowering the threshold
-        if (adaptiveThreshold) {
-            let currentThreshold = threshold - 0.05;
+        if (options.adaptiveThreshold) {
+            let currentThreshold = (options.threshold || 0.7) - 0.05;
             const minThreshold = 0.3; // Don't go below this to avoid irrelevant matches
             while (currentThreshold >= minThreshold && results.length < minResults) {
                 const newResults = await this.recallWithThreshold({
-                    query,
+                    query: options.query,
                     threshold: currentThreshold,
-                    agentId,
-                    limit,
-                    filters,
-                    createdAtFilter,
-                    expiresAtFilter
+                    agentId: options.agentId,
+                    limit: options.limit,
+                    filters: options.filters,
+                    createdAtFilter: options.createdAtFilter,
+                    expiresAtFilter: options.expiresAtFilter
                 });
                 // Add new results that aren't already in the list
                 for (const result of newResults) {
@@ -572,20 +604,20 @@ class MeshOS {
             }
         }
         // Third try: If we still don't have ANY results and semantic expansion is enabled
-        if (results.length === 0 && useSemanticExpansion) {
-            const variations = await this.expandQuery(query);
+        if (results.length === 0 && options.useSemanticExpansion) {
+            const variations = await this.expandQuery(options.query);
             const seenIds = new Map();
             const minThreshold = 0.3; // Don't go below this to avoid irrelevant matches
             // Try each variation with the original threshold first
             for (const variation of variations.slice(1)) { // Skip original query as we already tried it
                 const variationResults = await this.recallWithThreshold({
                     query: variation,
-                    threshold,
-                    agentId,
-                    limit,
-                    filters,
-                    createdAtFilter,
-                    expiresAtFilter
+                    threshold: options.threshold || 0.7,
+                    agentId: options.agentId,
+                    limit: options.limit,
+                    filters: options.filters,
+                    createdAtFilter: options.createdAtFilter,
+                    expiresAtFilter: options.expiresAtFilter
                 });
                 // Add new results or update if better similarity
                 for (const memory of variationResults) {
@@ -599,18 +631,18 @@ class MeshOS {
                 }
             }
             // If still no results, try variations with adaptive threshold
-            if (seenIds.size === 0 && adaptiveThreshold) {
-                let currentThreshold = threshold - 0.05;
+            if (seenIds.size === 0 && options.adaptiveThreshold) {
+                let currentThreshold = (options.threshold || 0.7) - 0.05;
                 while (currentThreshold >= minThreshold && seenIds.size === 0) {
                     for (const variation of variations.slice(1)) {
                         const variationResults = await this.recallWithThreshold({
                             query: variation,
                             threshold: currentThreshold,
-                            agentId,
-                            limit,
-                            filters,
-                            createdAtFilter,
-                            expiresAtFilter
+                            agentId: options.agentId,
+                            limit: options.limit,
+                            filters: options.filters,
+                            createdAtFilter: options.createdAtFilter,
+                            expiresAtFilter: options.expiresAtFilter
                         });
                         for (const memory of variationResults) {
                             const existingMemory = seenIds.get(memory.id);
@@ -635,7 +667,7 @@ class MeshOS {
         }
         // Sort by similarity and return top results
         results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
-        return results.slice(0, limit);
+        return results.slice(0, options.limit || 5);
     }
     /**
      * Internal method to perform recall with a specific threshold.

package/dist/core/entities.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Entity management functionality for MeshOS.
+ */
+import { Entity, EntityStatus, EntityRelationshipType, EntityMemoryLink } from './taxonomy';
+import type { Memory } from './client';
+export declare class EntityManager {
+    private url;
+    private headers;
+    private createEmbedding;
+    constructor(url: string, headers: Record<string, string>, createEmbedding: (text: string) => Promise<number[]>);
+    /**
+     * Execute a GraphQL query.
+     */
+    private executeQuery;
+    /**
+     * Add a new entity.
+     */
+    add(entity: Omit<Entity, 'id' | 'createdAt' | 'updatedAt'>): Promise<Entity>;
+    /**
+     * Get an entity by ID.
+     */
+    get(id: string): Promise<Entity | null>;
+    /**
+     * Get an entity by reference ID.
+     */
+    getByRefId(refId: string): Promise<Entity | null>;
+    /**
+     * Update an entity.
+     */
+    update(id: string, updates: Partial<Omit<Entity, 'id' | 'createdAt' | 'updatedAt'>>): Promise<Entity>;
+    /**
+     * Delete an entity.
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Search entities by semantic similarity.
+     */
+    search(options: {
+        query: string;
+        threshold?: number;
+        limit?: number;
+        type?: string;
+        status?: EntityStatus;
+    }): Promise<(Entity & {
+        similarity?: number;
+    })[]>;
+    /**
+     * Link an entity to a memory.
+     */
+    linkMemory(entityId: string, memoryId: string, relationship: EntityRelationshipType, confidence?: number, metadata?: Record<string, unknown>): Promise<EntityMemoryLink>;
+    /**
+     * Get all memories linked to an entity.
+     */
+    getLinkedMemories(entityId: string, relationship?: EntityRelationshipType): Promise<Array<Memory & {
+        relationship: EntityRelationshipType;
+        confidence: number;
+    }>>;
+}

package/dist/core/entities.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityManager = void 0;
+/**
+ * Entity management functionality for MeshOS.
+ */
+const taxonomy_1 = require("./taxonomy");
+class EntityManager {
+    constructor(url, headers, createEmbedding) {
+        this.url = url;
+        this.headers = headers;
+        this.createEmbedding = createEmbedding;
+    }
+    /**
+     * 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 Error(result.errors[0].message);
+        }
+        return result.data;
+    }
+    /**
+     * Add a new entity.
+     */
+    async add(entity) {
+        // Validate entity data
+        const validatedData = taxonomy_1.entitySchema.omit({ id: true, createdAt: true, updatedAt: true }).parse(entity);
+        // Create embedding from name and description
+        const embeddingText = `${validatedData.name} ${validatedData.description || ''}`.trim();
+        const embedding = await this.createEmbedding(embeddingText);
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const query = `
+      mutation AddEntity($entity: entities_insert_input!) {
+        insert_entities_one(object: $entity) {
+          id
+          ref_id
+          type
+          name
+          description
+          metadata
+          status
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            entity: {
+                ref_id: validatedData.refId,
+                type: validatedData.type,
+                name: validatedData.name,
+                description: validatedData.description,
+                metadata: validatedData.metadata,
+                status: validatedData.status,
+                embedding: embeddingStr
+            }
+        });
+        // Convert snake_case to camelCase
+        const { ref_id, created_at, updated_at, ...rest } = result.insert_entities_one;
+        return {
+            ...rest,
+            refId: ref_id,
+            createdAt: created_at,
+            updatedAt: updated_at,
+        };
+    }
+    /**
+     * Get an entity by ID.
+     */
+    async get(id) {
+        const query = `
+      query GetEntity($id: uuid!) {
+        entities_by_pk(id: $id) {
+          id
+          ref_id
+          type
+          name
+          description
+          metadata
+          status
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        if (!result.entities_by_pk) {
+            return null;
+        }
+        // Convert snake_case to camelCase
+        const { ref_id, created_at, updated_at, ...rest } = result.entities_by_pk;
+        return {
+            ...rest,
+            refId: ref_id,
+            createdAt: created_at,
+            updatedAt: updated_at,
+        };
+    }
+    /**
+     * Get an entity by reference ID.
+     */
+    async getByRefId(refId) {
+        const query = `
+      query GetEntityByRefId($refId: String!) {
+        entities(where: {ref_id: {_eq: $refId}}, limit: 1) {
+          id
+          ref_id
+          type
+          name
+          description
+          metadata
+          status
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { refId });
+        if (!result.entities[0]) {
+            return null;
+        }
+        // Convert snake_case to camelCase
+        const { ref_id, created_at, updated_at, ...rest } = result.entities[0];
+        return {
+            ...rest,
+            refId: ref_id,
+            createdAt: created_at,
+            updatedAt: updated_at,
+        };
+    }
+    /**
+     * Update an entity.
+     */
+    async update(id, updates) {
+        // If name or description is updated, update embedding
+        let embedding;
+        if (updates.name || updates.description) {
+            const entity = await this.get(id);
+            if (!entity) {
+                throw new Error(`Entity ${id} not found`);
+            }
+            const embeddingText = `${updates.name || entity.name} ${updates.description || entity.description || ''}`.trim();
+            embedding = await this.createEmbedding(embeddingText);
+        }
+        const query = `
+      mutation UpdateEntity($id: uuid!, $updates: entities_set_input!) {
+        update_entities_by_pk(pk_columns: {id: $id}, _set: $updates) {
+          id
+          ref_id
+          type
+          name
+          description
+          metadata
+          status
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const updateData = {
+            ref_id: updates.refId,
+            type: updates.type,
+            name: updates.name,
+            description: updates.description,
+            metadata: updates.metadata,
+            status: updates.status,
+        };
+        if (embedding) {
+            updateData.embedding = `[${embedding.join(',')}]`;
+        }
+        // Remove undefined values
+        Object.keys(updateData).forEach(key => updateData[key] === undefined && delete updateData[key]);
+        const result = await this.executeQuery(query, {
+            id,
+            updates: updateData
+        });
+        // Convert snake_case to camelCase
+        const { ref_id, created_at, updated_at, ...rest } = result.update_entities_by_pk;
+        return {
+            ...rest,
+            refId: ref_id,
+            createdAt: created_at,
+            updatedAt: updated_at,
+        };
+    }
+    /**
+     * Delete an entity.
+     */
+    async delete(id) {
+        const query = `
+      mutation DeleteEntity($id: uuid!) {
+        delete_entities_by_pk(id: $id) {
+          id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        return result.delete_entities_by_pk !== null;
+    }
+    /**
+     * Search entities by semantic similarity.
+     */
+    async search(options) {
+        const { query, threshold = 0.7, limit = 10, type, status } = options;
+        // Create embedding for search query
+        const embedding = await this.createEmbedding(query);
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const searchQuery = `
+      query SearchEntities(
+        $embedding: vector!,
+        $threshold: float8!,
+        $limit: Int!,
+        $type: String,
+        $status: String
+      ) {
+        entities(
+          where: {
+            _and: [
+              {type: {_eq: $type}},
+              {status: {_eq: $status}}
+            ]
+          },
+          order_by: {embedding: {_cosine_distance: $embedding}},
+          limit: $limit
+        ) {
+          id
+          ref_id
+          type
+          name
+          description
+          metadata
+          status
+          created_at
+          updated_at
+          similarity: _cosine_similarity_embedding_with($embedding)
+        }
+      }
+    `;
+        const result = await this.executeQuery(searchQuery, {
+            embedding: embeddingStr,
+            threshold,
+            limit,
+            type,
+            status
+        });
+        return result.entities.map(entity => {
+            const { ref_id, created_at, updated_at, ...rest } = entity;
+            return {
+                ...rest,
+                refId: ref_id,
+                createdAt: created_at,
+                updatedAt: updated_at,
+            };
+        }).filter(entity => (entity.similarity || 0) >= threshold);
+    }
+    /**
+     * Link an entity to a memory.
+     */
+    async linkMemory(entityId, memoryId, relationship, confidence, metadata) {
+        const query = `
+      mutation LinkEntityMemory($link: entity_memory_links_insert_input!) {
+        insert_entity_memory_links_one(object: $link) {
+          id
+          entity_id
+          memory_id
+          relationship
+          confidence
+          metadata
+          created_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            link: {
+                entity_id: entityId,
+                memory_id: memoryId,
+                relationship,
+                confidence: confidence || 1.0,
+                metadata: metadata || {}
+            }
+        });
+        // Convert snake_case to camelCase
+        const { entity_id, memory_id, created_at, ...rest } = result.insert_entity_memory_links_one;
+        return {
+            ...rest,
+            entityId: entity_id,
+            memoryId: memory_id,
+            createdAt: created_at,
+        };
+    }
+    /**
+     * Get all memories linked to an entity.
+     */
+    async getLinkedMemories(entityId, relationship) {
+        const query = `
+      query GetLinkedMemories($entityId: uuid!, $relationship: String) {
+        entity_memory_links(
+          where: {
+            entity_id: {_eq: $entityId},
+            relationship: {_eq: $relationship}
+          }
+        ) {
+          memory {
+            id
+            agent_id
+            content
+            metadata
+            created_at
+            updated_at
+            expires_at
+          }
+          relationship
+          confidence
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            entityId,
+            relationship
+        });
+        return result.entity_memory_links.map(link => {
+            const { memory, relationship, confidence } = link;
+            const { agent_id, created_at, updated_at, expires_at, ...rest } = memory;
+            return {
+                ...rest,
+                agentId: agent_id,
+                createdAt: created_at,
+                updatedAt: updated_at,
+                expiresAt: expires_at,
+                relationship,
+                confidence
+            };
+        });
+    }
+}
+exports.EntityManager = EntityManager;

package/dist/core/taxonomy.d.ts

@@ -11,6 +11,90 @@ export declare enum DataType {
     DECISION = "decision",// Strategic & operational choices
     MEDIA = "media"
 }
+/**
+ * Entity relationship types.
+ */
+export declare enum EntityRelationshipType {
+    ASSOCIATED = "associated",// Generic association
+    OWNS = "owns",// Ownership relationship
+    REFERENCES = "references",// Reference relationship
+    MENTIONS = "mentions",// Mention relationship
+    DESCRIBES = "describes",// Description relationship
+    PART_OF = "part_of"
+}
+/**
+ * Entity status types.
+ */
+export declare enum EntityStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    ARCHIVED = "archived",
+    DELETED = "deleted"
+}
+/**
+ * Entity schema definition.
+ */
+export declare const entitySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    refId: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof EntityStatus>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    status: EntityStatus;
+    metadata: Record<string, unknown>;
+    id?: string | undefined;
+    refId?: string | undefined;
+    description?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    type: string;
+    name: string;
+    id?: string | undefined;
+    refId?: string | undefined;
+    description?: string | undefined;
+    status?: EntityStatus | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}>;
+export type Entity = z.infer<typeof entitySchema>;
+/**
+ * Entity-memory link schema definition.
+ */
+export declare const entityMemoryLinkSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodString;
+    memoryId: z.ZodString;
+    relationship: z.ZodNativeEnum<typeof EntityRelationshipType>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    entityId: string;
+    memoryId: string;
+    relationship: EntityRelationshipType;
+    confidence: number;
+    id?: string | undefined;
+    createdAt?: string | undefined;
+}, {
+    entityId: string;
+    memoryId: string;
+    relationship: EntityRelationshipType;
+    id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    createdAt?: string | undefined;
+    confidence?: number | undefined;
+}>;
+export type EntityMemoryLink = z.infer<typeof entityMemoryLinkSchema>;
 /**
  * Subtypes for activity data.
  */
@@ -216,8 +300,8 @@ export declare const edgeMetadataSchema: z.ZodObject<{
     bidirectional: z.ZodDefault<z.ZodBoolean>;
     additional: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    additional: Record<string, unknown>;
     relationship: EdgeType;
+    additional: Record<string, unknown>;
     weight: number;
     bidirectional: boolean;
     validUntil?: Date | undefined;

package/dist/core/taxonomy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.edgeMetadataSchema = exports.memoryMetadataSchema = exports.CoreAgentStatus = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.DataType = void 0;
+exports.edgeMetadataSchema = exports.memoryMetadataSchema = exports.CoreAgentStatus = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.entityMemoryLinkSchema = exports.entitySchema = exports.EntityStatus = exports.EntityRelationshipType = exports.DataType = void 0;
 /**
  * Taxonomy and classification models for MeshOS.
  */
@@ -15,6 +15,54 @@ var DataType;
     DataType["DECISION"] = "decision";
     DataType["MEDIA"] = "media";
 })(DataType || (exports.DataType = DataType = {}));
+/**
+ * Entity relationship types.
+ */
+var EntityRelationshipType;
+(function (EntityRelationshipType) {
+    EntityRelationshipType["ASSOCIATED"] = "associated";
+    EntityRelationshipType["OWNS"] = "owns";
+    EntityRelationshipType["REFERENCES"] = "references";
+    EntityRelationshipType["MENTIONS"] = "mentions";
+    EntityRelationshipType["DESCRIBES"] = "describes";
+    EntityRelationshipType["PART_OF"] = "part_of";
+})(EntityRelationshipType || (exports.EntityRelationshipType = EntityRelationshipType = {}));
+/**
+ * Entity status types.
+ */
+var EntityStatus;
+(function (EntityStatus) {
+    EntityStatus["ACTIVE"] = "active";
+    EntityStatus["INACTIVE"] = "inactive";
+    EntityStatus["ARCHIVED"] = "archived";
+    EntityStatus["DELETED"] = "deleted";
+})(EntityStatus || (exports.EntityStatus = EntityStatus = {}));
+/**
+ * Entity schema definition.
+ */
+exports.entitySchema = zod_1.z.object({
+    id: zod_1.z.string().uuid().optional(),
+    refId: zod_1.z.string().optional(),
+    type: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).default({}),
+    status: zod_1.z.nativeEnum(EntityStatus).default(EntityStatus.ACTIVE),
+    createdAt: zod_1.z.string().optional(),
+    updatedAt: zod_1.z.string().optional(),
+});
+/**
+ * Entity-memory link schema definition.
+ */
+exports.entityMemoryLinkSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid().optional(),
+    entityId: zod_1.z.string().uuid(),
+    memoryId: zod_1.z.string().uuid(),
+    relationship: zod_1.z.nativeEnum(EntityRelationshipType),
+    confidence: zod_1.z.number().min(0).max(1).default(1.0),
+    metadata: zod_1.z.record(zod_1.z.unknown()).default({}),
+    createdAt: zod_1.z.string().optional(),
+});
 /**
  * Subtypes for activity data.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@props-labs/mesh-os",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/templates/hasura/migrations/default/4_remove_slug_validation/down.sql

@@ -0,0 +1,20 @@
+-- First drop the constraint since it depends on the function
+ALTER TABLE public.agents DROP CONSTRAINT IF EXISTS valid_slug;
+
+-- Now we can safely drop and recreate the function
+DROP FUNCTION IF EXISTS validate_slug(text);
+CREATE OR REPLACE FUNCTION validate_slug(slug text)
+RETURNS boolean AS $$
+BEGIN
+    RETURN slug ~ '^[a-z][a-z0-9_-]*[a-z0-9]$';
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+-- Update any existing invalid slugs to NULL
+UPDATE public.agents 
+SET slug = NULL 
+WHERE slug IS NOT NULL AND NOT validate_slug(slug);
+
+-- Finally add back the constraint
+ALTER TABLE public.agents
+ADD CONSTRAINT valid_slug CHECK (slug IS NULL OR validate_slug(slug)); 

package/src/templates/hasura/migrations/default/4_remove_slug_validation/up.sql

@@ -0,0 +1,5 @@
+-- Drop the valid_slug constraint from the agents table
+ALTER TABLE public.agents DROP CONSTRAINT IF EXISTS valid_slug;
+
+-- Drop the validate_slug function
+DROP FUNCTION IF EXISTS validate_slug(text); 

package/src/templates/hasura/migrations/default/5_entities/down.sql

@@ -0,0 +1,13 @@
+-- Drop the combined search function
+DROP FUNCTION IF EXISTS search_memories_and_entities;
+
+-- Drop the combined search results view
+DROP VIEW IF EXISTS public.search_results_with_similarity;
+
+-- Drop triggers
+DROP TRIGGER IF EXISTS update_entities_updated_at ON public.entities;
+DROP TRIGGER IF EXISTS normalize_entity_embedding ON public.entities;
+
+-- Drop tables (order matters due to foreign key constraints)
+DROP TABLE IF EXISTS public.entity_memory_links;
+DROP TABLE IF EXISTS public.entities;

package/src/templates/hasura/migrations/default/5_entities/up.sql

@@ -0,0 +1,155 @@
+-- Create entities table with embedding support
+CREATE TABLE IF NOT EXISTS public.entities (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    ref_id TEXT UNIQUE,
+    type TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    metadata JSONB,
+    embedding vector(1536),
+    status TEXT NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Create entity-memory links table
+CREATE TABLE IF NOT EXISTS public.entity_memory_links (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    entity_id UUID NOT NULL REFERENCES public.entities(id) ON DELETE CASCADE,
+    memory_id UUID NOT NULL REFERENCES public.memories(id) ON DELETE CASCADE,
+    relationship TEXT NOT NULL,
+    confidence FLOAT DEFAULT 1.0,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    UNIQUE(entity_id, memory_id, relationship)
+);
+
+-- Create index for vector similarity search
+CREATE INDEX IF NOT EXISTS idx_entities_embedding 
+ON public.entities USING ivfflat (embedding vector_cosine_ops)
+WITH (lists = 100);
+
+-- Create trigger for updated_at
+CREATE TRIGGER update_entities_updated_at
+    BEFORE UPDATE ON public.entities
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Add normalization trigger for entities
+CREATE TRIGGER normalize_entity_embedding
+    BEFORE INSERT OR UPDATE OF embedding ON public.entities
+    FOR EACH ROW
+    EXECUTE FUNCTION normalize_embedding();
+
+-- Create a view for combined search results
+CREATE OR REPLACE VIEW public.search_results_with_similarity AS
+SELECT 
+    id,
+    'memory'::text as type,
+    content,
+    metadata,
+    0::float8 as similarity
+FROM memories
+UNION ALL
+SELECT 
+    id,
+    'entity'::text as type,
+    name as content,
+    metadata,
+    0::float8 as similarity
+FROM entities;
+
+-- Create combined search function
+CREATE OR REPLACE FUNCTION search_memories_and_entities(
+    query_embedding vector(1536),
+    match_threshold float8,
+    match_count integer,
+    include_entities boolean DEFAULT true,
+    include_memories boolean DEFAULT true,
+    metadata_filter jsonb DEFAULT NULL,
+    created_at_filter jsonb DEFAULT NULL
+)
+RETURNS SETOF public.search_results_with_similarity
+LANGUAGE sql STABLE AS $$
+    WITH normalized_query AS (
+        SELECT l2_normalize(query_embedding) AS normalized_vector
+    )
+    (
+        SELECT 
+            m.id,
+            'memory'::text as type,
+            m.content,
+            m.metadata,
+            -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+        FROM memories m
+        WHERE include_memories = true
+        AND CASE
+            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN created_at_filter IS NOT NULL THEN (
+                CASE
+                    WHEN created_at_filter ? '_gt' THEN m.created_at > (created_at_filter->>'_gt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_gte' THEN m.created_at >= (created_at_filter->>'_gte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lt' THEN m.created_at < (created_at_filter->>'_lt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lte' THEN m.created_at <= (created_at_filter->>'_lte')::timestamptz
+                    ELSE TRUE
+                END
+            )
+            ELSE TRUE
+        END
+        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    )
+    UNION ALL
+    (
+        SELECT 
+            e.id,
+            'entity'::text as type,
+            e.name as content,
+            e.metadata,
+            -(e.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+        FROM entities e
+        WHERE include_entities = true
+        AND CASE
+            WHEN metadata_filter IS NOT NULL THEN e.metadata @> metadata_filter
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN created_at_filter IS NOT NULL THEN (
+                CASE
+                    WHEN created_at_filter ? '_gt' THEN e.created_at > (created_at_filter->>'_gt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_gte' THEN e.created_at >= (created_at_filter->>'_gte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lt' THEN e.created_at < (created_at_filter->>'_lt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lte' THEN e.created_at <= (created_at_filter->>'_lte')::timestamptz
+                    ELSE TRUE
+                END
+            )
+            ELSE TRUE
+        END
+        AND -(e.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    )
+    ORDER BY similarity DESC
+    LIMIT match_count;
+$$;
+
+-- Track the function in Hasura
+COMMENT ON FUNCTION search_memories_and_entities IS E'@graphql({"type": "Query"})';