@props-labs/mesh-os 0.2.2 → 0.2.4

package/dist/core/__fixtures__/mock_responses.d.ts

@@ -171,6 +171,23 @@ export declare const MEMORY_MOCKS: {
             })[];
         };
     };
+    listMemories: {
+        data: {
+            memories: {
+                id: string;
+                type: string;
+                status: string;
+                content: string;
+                metadata: {
+                    source: string;
+                    tags: string[];
+                };
+                created_at: string;
+                updated_at: string;
+                agent_id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+            }[];
+        };
+    };
 };
 export declare const WORKFLOW_MOCKS: {
     listSchemas: {

package/dist/core/__fixtures__/mock_responses.js

@@ -151,6 +151,51 @@ exports.MEMORY_MOCKS = {
                 }
             ]
         }
+    },
+    listMemories: {
+        data: {
+            memories: [
+                {
+                    id: exports.SAMPLE_IDS.MEMORY,
+                    type: 'text_document',
+                    status: 'active',
+                    content: 'Test memory 1',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'first']
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                },
+                {
+                    id: '22222222-2222-2222-2222-222222222222',
+                    type: 'code_snippet',
+                    status: 'active',
+                    content: 'Test memory 2',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'second']
+                    },
+                    created_at: '2025-02-18T00:00:01Z',
+                    updated_at: '2025-02-18T00:00:01Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                },
+                {
+                    id: '33333333-3333-3333-3333-333333333333',
+                    type: 'text_document',
+                    status: 'archived',
+                    content: 'Test memory 3',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'third']
+                    },
+                    created_at: '2025-02-18T00:00:02Z',
+                    updated_at: '2025-02-18T00:00:02Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                }
+            ]
+        }
     }
 };
 // Workflow mock responses
@@ -343,6 +388,9 @@ const createMockFetch = (mocks) => {
         else if (query.includes('GetLastWorkflowResult')) {
             mockResponse = mocks.getLastResult;
         }
+        else if (query.includes('ListMemories')) {
+            mockResponse = mocks.listMemories;
+        }
         if (!mockResponse) {
             throw new Error(`No mock response found for query: ${query}`);
         }

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

@@ -76,6 +76,17 @@ export interface SearchMemoryOptions {
     metadataFilter?: Record<string, any>;
     createdAtFilter?: Record<string, any>;
 }
+export interface ListMemoriesOptions {
+    type?: string;
+    status?: 'active' | 'archived' | 'deleted';
+    limit?: number;
+    offset?: number;
+    agentId?: string;
+    orderBy?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
 export interface UpdateMemoryInput {
     id: string;
     content?: string;
@@ -135,4 +146,8 @@ export declare class MemoryManager {
      * List all available type schemas
      */
     listSchemas(): Promise<TypeSchema[]>;
+    /**
+     * List memories with optional filtering and pagination
+     */
+    listMemories(options?: ListMemoriesOptions): Promise<Memory[]>;
 }

package/dist/core/memories.js

@@ -413,5 +413,54 @@ class MemoryManager {
         const result = await this.executeQuery(query, {});
         return result.type_schemas.map(schema => typeSchemaSchema.parse(schema));
     }
+    /**
+     * List memories with optional filtering and pagination
+     */
+    async listMemories(options = {}) {
+        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 (status)
+            where.status = { _eq: status };
+        if (agentId)
+            where.agent_id = { _eq: agentId };
+        // Convert orderBy to Hasura format
+        const orderByClause = orderBy.map(({ field, direction }) => ({
+            [field]: direction
+        }));
+        const query = `
+      query ListMemories(
+        $where: memories_bool_exp!,
+        $limit: Int!,
+        $offset: Int!,
+        $orderBy: [memories_order_by!]!
+      ) {
+        memories(
+          where: $where,
+          limit: $limit,
+          offset: $offset,
+          order_by: $orderBy
+        ) {
+          id
+          type
+          status
+          metadata
+          content
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            where,
+            limit,
+            offset,
+            orderBy: orderByClause
+        });
+        return result.memories.map(memory => memorySchema.parse(memory));
+    }
 }
 exports.MemoryManager = MemoryManager;

package/package.json

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