@props-labs/mesh-os 0.2.0 → 0.2.2

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

@@ -311,6 +311,25 @@ export declare const WORKFLOW_MOCKS: {
             };
         };
     };
+    getLastResult: {
+        data: {
+            workflow_results: {
+                id: string;
+                workflow_id: "c4d5e6f7-3456-7890-12cd-ef3456789012";
+                type: string;
+                result: {
+                    summary: string;
+                    confidence: number;
+                };
+                metadata: {
+                    stage: string;
+                };
+                created_at: string;
+                updated_at: string;
+                agent_id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+            }[];
+        };
+    };
 };
 export declare const createMockFetch: (mocks: Record<string, any>) => (url: string, init?: RequestInit) => Promise<{
     ok: boolean;

package/dist/core/__fixtures__/mock_responses.js

@@ -288,6 +288,25 @@ exports.WORKFLOW_MOCKS = {
                 agent_id: exports.SAMPLE_IDS.AGENT
             }
         }
+    },
+    getLastResult: {
+        data: {
+            workflow_results: [{
+                    id: 'd5e6f7f8-4567-8901-23de-f45678901235',
+                    workflow_id: exports.SAMPLE_IDS.WORKFLOW,
+                    type: 'final',
+                    result: {
+                        summary: 'This is the document summary',
+                        confidence: 0.95
+                    },
+                    metadata: {
+                        stage: 'complete'
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                }]
+        }
     }
 };
 // Mock fetch function for testing
@@ -321,6 +340,9 @@ const createMockFetch = (mocks) => {
         else if (query.includes('CreateWorkflowRun')) {
             mockResponse = mocks.createRun;
         }
+        else if (query.includes('GetLastWorkflowResult')) {
+            mockResponse = mocks.getLastResult;
+        }
         if (!mockResponse) {
             throw new Error(`No mock response found for query: ${query}`);
         }

package/dist/core/client.d.ts

@@ -1,6 +1,7 @@
-import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter, EntityRelationshipType } from './taxonomy';
-import { EntityManager } from './entities';
+import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter } from './taxonomy';
 import { WorkflowManager } from './workflows';
+import { MemoryManager } from './memories';
+import { AgentManager } from './agents';
 /**
  * An agent in the system.
  */
@@ -66,8 +67,6 @@ export interface RememberOptions {
     agentId: string;
     metadata?: Partial<MemoryMetadata>;
     expiresAt?: string;
-    entityId?: string;
-    entityRelationship?: EntityRelationshipType;
 }
 /**
  * MeshOS client for interacting with the system.
@@ -76,8 +75,9 @@ export declare class MeshOS {
     private url;
     private headers;
     private openai;
-    entities: EntityManager;
     workflows: WorkflowManager;
+    memories: MemoryManager;
+    agents: AgentManager;
     constructor(config?: MeshOSConfig);
     private validateSlug;
     /**
@@ -156,8 +156,6 @@ 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,8 +11,9 @@ 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");
 const workflows_1 = require("./workflows");
+const memories_1 = require("./memories");
+const agents_1 = require("./agents");
 // Constants
 const SLUG_PATTERN = /^[a-zA-Z0-9_-]+$/;
 /**
@@ -63,8 +64,9 @@ class MeshOS {
         }
         this.openai = new openai_1.default({ apiKey: openaiApiKey });
         // Initialize managers
-        this.entities = new entities_1.EntityManager(this.url, this.headers, this.createEmbedding.bind(this));
         this.workflows = new workflows_1.WorkflowManager(this.url, this.headers);
+        this.memories = new memories_1.MemoryManager(this.url, this.headers, this.createEmbedding.bind(this));
+        this.agents = new agents_1.AgentManager(this.url, this.headers);
     }
     validateSlug(slug) {
         return SLUG_PATTERN.test(slug);
@@ -203,7 +205,7 @@ class MeshOS {
      * Store a new memory with optional entity linking.
      */
     async remember(options, agentId, metadata, expiresAt) {
-        // Handle legacy method signature
+        // Convert string input to options object
         if (typeof options === 'string') {
             options = {
                 content: options,
@@ -212,14 +214,7 @@ class MeshOS {
                 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;
     }
     /**
@@ -543,12 +538,6 @@ class MeshOS {
             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, options.limit || 5);

package/dist/core/workflows.d.ts

@@ -101,4 +101,8 @@ export declare class WorkflowManager {
      * List workflow runs with optional filtering and sorting
      */
     listRuns(options?: ListWorkflowRunsOptions): Promise<WorkflowRun[]>;
+    /**
+     * Get the last result for a workflow run, regardless of type
+     */
+    getLastResult(workflowId: string): Promise<WorkflowResult | null>;
 }

package/dist/core/workflows.js

@@ -328,5 +328,30 @@ class WorkflowManager {
         });
         return result.workflow_runs.map(run => workflowRunSchema.parse(run));
     }
+    /**
+     * Get the last result for a workflow run, regardless of type
+     */
+    async getLastResult(workflowId) {
+        const query = `
+      query GetLastWorkflowResult($workflow_id: uuid!) {
+        workflow_results(
+          where: {workflow_id: {_eq: $workflow_id}}
+          order_by: {created_at: desc}
+          limit: 1
+        ) {
+          id
+          workflow_id
+          type
+          result
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { workflow_id: workflowId });
+        return result.workflow_results[0] ? workflowResultSchema.parse(result.workflow_results[0]) : null;
+    }
 }
 exports.WorkflowManager = WorkflowManager;

package/package.json

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

package/dist/core/entities.d.ts

@@ -1,58 +0,0 @@
-/**
- * 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): 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

@@ -1,347 +0,0 @@
-"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) {
-        const query = `
-      mutation LinkEntityMemory($link: entity_memory_links_insert_input!) {
-        insert_entity_memory_links_one(object: $link) {
-          id
-          entity_id
-          memory_id
-          relationship
-          confidence
-          created_at
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, {
-            link: {
-                entity_id: entityId,
-                memory_id: memoryId,
-                relationship,
-                confidence: confidence || 1.0
-            }
-        });
-        // 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;