@props-labs/mesh-os 0.2.3 → 0.2.6

package/dist/core/client.d.ts

@@ -58,6 +58,7 @@ export interface MeshOSConfig {
     url?: string;
     apiKey?: string;
     openaiApiKey?: string;
+    dangerouslyAllowBrowser?: boolean;
 }
 /**
  * Memory creation options with entity support.

package/dist/core/client.js

@@ -8,8 +8,6 @@ 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");
 const workflows_1 = require("./workflows");
 const memories_1 = require("./memories");
@@ -41,28 +39,19 @@ exports.InvalidSlugError = InvalidSlugError;
  */
 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;
+        const { url = 'http://localhost:8080/v1/graphql', apiKey = 'meshos', openaiApiKey = process.env.OPENAI_API_KEY, dangerouslyAllowBrowser = false } = config;
         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');
+            throw new Error('OpenAI API key is required. Please provide it in the config or set OPENAI_API_KEY environment variable.');
         }
-        this.openai = new openai_1.default({ apiKey: openaiApiKey });
+        this.url = url;
+        this.headers = {
+            'x-hasura-admin-secret': apiKey,
+            'Content-Type': 'application/json'
+        };
+        this.openai = new openai_1.default({
+            apiKey: openaiApiKey,
+            dangerouslyAllowBrowser
+        });
         // Initialize managers
         this.workflows = new workflows_1.WorkflowManager(this.url, this.headers);
         this.memories = new memories_1.MemoryManager(this.url, this.headers, this.createEmbedding.bind(this));

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.3",
+  "version": "0.2.6",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",