@props-labs/mesh-os 0.1.23 → 0.2.2

package/dist/core/agents.d.ts

@@ -0,0 +1,51 @@
+export interface Agent {
+    id: string;
+    name: string | null;
+    description: string | null;
+    slug: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateAgentInput {
+    name?: string | null;
+    description?: string | null;
+}
+export interface UpdateAgentInput {
+    id: string;
+    name?: string | null;
+    description?: string | null;
+}
+export interface RegisterAgentInput {
+    name?: string | null;
+    description?: string | null;
+    slug?: string | null;
+}
+export declare class InvalidSlugError extends Error {
+    constructor(message: string);
+}
+export declare class AgentManager {
+    private url;
+    private headers;
+    constructor(url: string, headers: Record<string, string>);
+    private validateSlug;
+    /**
+     * Execute a GraphQL query against Hasura
+     */
+    private executeQuery;
+    /**
+     * Get an agent by slug
+     */
+    getBySlug(slug: string): Promise<Agent | null>;
+    /**
+     * Register a new agent or return existing one if slug exists
+     */
+    register(input: RegisterAgentInput): Promise<Agent>;
+    /**
+     * Get an agent by ID
+     */
+    get(id: string): Promise<Agent>;
+    /**
+     * Update an agent
+     */
+    update(input: UpdateAgentInput): Promise<Agent>;
+}

package/dist/core/agents.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentManager = exports.InvalidSlugError = void 0;
+const zod_1 = require("zod");
+// Validation schemas
+const agentSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    name: zod_1.z.string().nullable(),
+    description: zod_1.z.string().nullable(),
+    slug: zod_1.z.string().nullable(),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string()
+});
+// Slug pattern for validation
+const SLUG_PATTERN = /^[a-zA-Z0-9_-]+$/;
+class InvalidSlugError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidSlugError';
+    }
+}
+exports.InvalidSlugError = InvalidSlugError;
+class AgentManager {
+    constructor(url, headers) {
+        this.url = url;
+        this.headers = headers;
+    }
+    validateSlug(slug) {
+        return SLUG_PATTERN.test(slug);
+    }
+    /**
+     * Execute a GraphQL query against Hasura
+     */
+    async executeQuery(query, variables) {
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers
+            },
+            body: JSON.stringify({
+                query,
+                variables
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to execute query: ${response.statusText}`);
+        }
+        const result = (await response.json());
+        if (result.errors) {
+            throw new Error(`GraphQL error: ${result.errors[0].message}`);
+        }
+        return result.data;
+    }
+    /**
+     * Get an agent by slug
+     */
+    async getBySlug(slug) {
+        if (!this.validateSlug(slug)) {
+            throw new InvalidSlugError("Slug must contain only URL-safe characters (letters, numbers, hyphens, and underscores)");
+        }
+        const query = `
+      query GetAgentBySlug($slug: String!) {
+        agents(where: {slug: {_eq: $slug}}, limit: 1) {
+          id
+          name
+          description
+          slug
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { slug });
+        return result.agents[0] ? agentSchema.parse(result.agents[0]) : null;
+    }
+    /**
+     * Register a new agent or return existing one if slug exists
+     */
+    async register(input) {
+        if (input.slug) {
+            if (!this.validateSlug(input.slug)) {
+                throw new InvalidSlugError("Slug must contain only URL-safe characters (letters, numbers, hyphens, and underscores)");
+            }
+            // Check for existing agent with this slug
+            const existing = await this.getBySlug(input.slug);
+            if (existing) {
+                return existing;
+            }
+        }
+        const query = `
+      mutation RegisterAgent($agent: agents_insert_input!) {
+        insert_agents_one(object: $agent) {
+          id
+          name
+          description
+          slug
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            agent: {
+                name: input.name,
+                description: input.description,
+                slug: input.slug
+            }
+        });
+        return agentSchema.parse(result.insert_agents_one);
+    }
+    /**
+     * Get an agent by ID
+     */
+    async get(id) {
+        const query = `
+      query GetAgent($id: uuid!) {
+        agents_by_pk(id: $id) {
+          id
+          name
+          description
+          slug
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        const agent = result.agents_by_pk;
+        if (!agent) {
+            throw new Error(`Agent not found with id: ${id}`);
+        }
+        return agentSchema.parse(agent);
+    }
+    /**
+     * Update an agent
+     */
+    async update(input) {
+        // First verify the agent exists
+        await this.get(input.id);
+        // Prepare update object with only changed fields
+        const updateFields = {};
+        if (input.name !== undefined)
+            updateFields.name = input.name;
+        if (input.description !== undefined)
+            updateFields.description = input.description;
+        // If no fields to update, return existing agent
+        if (Object.keys(updateFields).length === 0) {
+            return this.get(input.id);
+        }
+        const query = `
+      mutation UpdateAgent($id: uuid!, $updates: agents_set_input!) {
+        update_agents_by_pk(pk_columns: {id: $id}, _set: $updates) {
+          id
+          name
+          description
+          slug
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: input.id,
+            updates: updateFields
+        });
+        return agentSchema.parse(result.update_agents_by_pk);
+    }
+}
+exports.AgentManager = AgentManager;

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/memories.d.ts

@@ -0,0 +1,138 @@
+export interface Memory {
+    id: string;
+    type: string;
+    status: 'active' | 'archived' | 'deleted';
+    metadata: Record<string, any>;
+    content: string;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string | null;
+}
+export interface MemoryChunk {
+    id: string;
+    memory_id: string;
+    chunk_index: number;
+    content: string;
+    embedding?: number[];
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string | null;
+}
+export interface MemoryEdge {
+    id: string;
+    source_memory: string;
+    target_memory: string;
+    type: string;
+    metadata: Record<string, any>;
+    weight: number;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string;
+}
+export interface TypeSchema {
+    type: string;
+    schema: Record<string, any>;
+    metadata_schema?: Record<string, any> | null;
+    embedding_config?: {
+        model: string;
+        dimensions: number;
+    } | null;
+    chunking_config?: {
+        chunk_size: number;
+        chunk_overlap: number;
+    } | null;
+    validation_rules?: Record<string, any> | null;
+    behaviors?: Record<string, any> | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateMemoryInput {
+    type: string;
+    content: string;
+    metadata?: Record<string, any>;
+    agent_id?: string;
+}
+export interface CreateMemoryResult {
+    memory: Memory;
+    chunkCount: number;
+}
+export interface SearchMemoryResult {
+    id: string;
+    type: string;
+    status: string;
+    content: string;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string;
+    similarity: number;
+}
+export interface SearchMemoryOptions {
+    query: string;
+    threshold?: number;
+    limit?: number;
+    agentId?: string;
+    metadataFilter?: Record<string, any>;
+    createdAtFilter?: Record<string, any>;
+}
+export interface UpdateMemoryInput {
+    id: string;
+    content?: string;
+    metadata?: Record<string, any>;
+    status?: 'active' | 'archived' | 'deleted';
+}
+export interface UpdateMemoryResult {
+    memory: Memory;
+    chunkCount?: number;
+}
+export declare class MemoryManager {
+    private url;
+    private headers;
+    private createEmbedding;
+    constructor(url: string, headers: Record<string, string>, createEmbedding: (text: string) => Promise<number[]>);
+    /**
+     * Execute a GraphQL query against Hasura
+     */
+    private executeQuery;
+    /**
+     * Get a memory by its ID
+     */
+    get(id: string): Promise<Memory>;
+    /**
+     * Get a type schema by its type name
+     */
+    getTypeSchema(type: string): Promise<TypeSchema>;
+    /**
+     * Create chunks from content based on type schema configuration
+     */
+    private createChunks;
+    /**
+     * Create a new memory with chunks and embeddings
+     */
+    create(input: CreateMemoryInput): Promise<CreateMemoryResult>;
+    /**
+     * Search memories by semantic similarity using chunk embeddings
+     */
+    search(options: SearchMemoryOptions): Promise<SearchMemoryResult[]>;
+    /**
+     * Clean up test memories and their chunks
+     */
+    cleanup(memoryIds: string[]): Promise<void>;
+    /**
+     * Update an existing memory and optionally its chunks
+     */
+    update(input: UpdateMemoryInput): Promise<UpdateMemoryResult>;
+    /**
+     * Mark a memory as deleted
+     */
+    delete(id: string): Promise<Memory>;
+    /**
+     * Mark a memory as archived
+     */
+    archive(id: string): Promise<Memory>;
+    /**
+     * List all available type schemas
+     */
+    listSchemas(): Promise<TypeSchema[]>;
+}