@props-labs/mesh-os 0.2.4 → 0.2.6

package/dist/core/memories.d.ts

@@ -77,7 +77,7 @@ export interface SearchMemoryOptions {
     createdAtFilter?: Record<string, any>;
 }
 export interface ListMemoriesOptions {
-    type?: string;
+    type?: string | string[];
     status?: 'active' | 'archived' | 'deleted';
     limit?: number;
     offset?: number;
@@ -97,6 +97,21 @@ export interface UpdateMemoryResult {
     memory: Memory;
     chunkCount?: number;
 }
+export interface CreateTypeSchemaInput {
+    type: string;
+    schema: Record<string, any>;
+    metadata_schema?: Record<string, any>;
+    embedding_config?: {
+        model: string;
+        dimensions: number;
+    };
+    chunking_config?: {
+        chunk_size: number;
+        chunk_overlap: number;
+    };
+    validation_rules?: Record<string, any>;
+    behaviors?: Record<string, any>;
+}
 export declare class MemoryManager {
     private url;
     private headers;
@@ -150,4 +165,8 @@ export declare class MemoryManager {
      * List memories with optional filtering and pagination
      */
     listMemories(options?: ListMemoriesOptions): Promise<Memory[]>;
+    /**
+     * Create a new type schema
+     */
+    createTypeSchema(input: CreateTypeSchemaInput): Promise<TypeSchema>;
 }

package/dist/core/memories.js

@@ -420,8 +420,11 @@ class MemoryManager {
         const { type, status, limit = 10, offset = 0, agentId, orderBy = [{ field: 'created_at', direction: 'desc' }] } = options;
         // Build where clause
         const where = {};
-        if (type)
-            where.type = { _eq: type };
+        if (type) {
+            where.type = Array.isArray(type)
+                ? { _in: type } // If array, use _in operator
+                : { _eq: type }; // If single string, use _eq operator
+        }
         if (status)
             where.status = { _eq: status };
         if (agentId)
@@ -462,5 +465,37 @@ class MemoryManager {
         });
         return result.memories.map(memory => memorySchema.parse(memory));
     }
+    /**
+     * Create a new type schema
+     */
+    async createTypeSchema(input) {
+        const query = `
+      mutation CreateTypeSchema($schema: type_schemas_insert_input!) {
+        insert_type_schemas_one(object: $schema) {
+          type
+          schema
+          metadata_schema
+          embedding_config
+          chunking_config
+          validation_rules
+          behaviors
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            schema: {
+                type: input.type,
+                schema: input.schema,
+                metadata_schema: input.metadata_schema || null,
+                embedding_config: input.embedding_config || null,
+                chunking_config: input.chunking_config || null,
+                validation_rules: input.validation_rules || null,
+                behaviors: input.behaviors || null
+            }
+        });
+        return typeSchemaSchema.parse(result.insert_type_schemas_one);
+    }
 }
 exports.MemoryManager = MemoryManager;

package/package.json

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