@props-labs/mesh-os 0.1.20 → 0.2.0

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,5 +1,6 @@
 import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter, EntityRelationshipType } from './taxonomy';
 import { EntityManager } from './entities';
+import { WorkflowManager } from './workflows';
 /**
  * An agent in the system.
  */
@@ -76,6 +77,7 @@ export declare class MeshOS {
     private headers;
     private openai;
     entities: EntityManager;
+    workflows: WorkflowManager;
     constructor(config?: MeshOSConfig);
     private validateSlug;
     /**
@@ -117,7 +119,7 @@ export declare class MeshOS {
     /**
      * Create a link between two memories.
      */
-    linkMemories(sourceMemoryId: string, targetMemoryId: string, relationship: EdgeType, weight?: number, metadata?: Partial<EdgeMetadata>): Promise<MemoryEdge>;
+    linkMemories(sourceMemoryId: string, targetMemoryId: string, relationship: EdgeType, weight?: number): Promise<MemoryEdge>;
     /**
      * Remove links between two memories.
      */

package/dist/core/client.js

@@ -12,6 +12,7 @@ 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");
 // Constants
 const SLUG_PATTERN = /^[a-zA-Z0-9_-]+$/;
 /**
@@ -61,8 +62,9 @@ class MeshOS {
             throw new Error('OpenAI API key is required');
         }
         this.openai = new openai_1.default({ apiKey: openaiApiKey });
-        // Initialize entity manager
+        // 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);
     }
     validateSlug(slug) {
         return SLUG_PATTERN.test(slug);
@@ -339,19 +341,9 @@ class MeshOS {
             memories.push(memory);
             // Link chunks sequentially
             if (previousChunkId) {
-                await this.linkMemories(previousChunkId, memory.id, taxonomy_1.EdgeType.FOLLOWS_UP, 1.0, {
-                    relationship: taxonomy_1.EdgeType.FOLLOWS_UP,
-                    weight: 1.0,
-                    bidirectional: false,
-                    additional: { is_chunk_link: true }
-                });
+                await this.linkMemories(previousChunkId, memory.id, taxonomy_1.EdgeType.FOLLOWS_UP, 1.0);
                 // Also add PART_OF relationship to show these are parts of the same content
-                await this.linkMemories(memory.id, previousChunkId, taxonomy_1.EdgeType.PART_OF, 1.0, {
-                    relationship: taxonomy_1.EdgeType.PART_OF,
-                    weight: 1.0,
-                    bidirectional: true,
-                    additional: { is_chunk_link: true }
-                });
+                await this.linkMemories(memory.id, previousChunkId, taxonomy_1.EdgeType.PART_OF, 1.0);
             }
             previousChunkId = memory.id;
         }
@@ -376,21 +368,19 @@ class MeshOS {
     /**
      * Create a link between two memories.
      */
-    async linkMemories(sourceMemoryId, targetMemoryId, relationship, weight = 1.0, metadata) {
+    async linkMemories(sourceMemoryId, targetMemoryId, relationship, weight = 1.0) {
         const query = `
       mutation LinkMemories(
         $sourceMemory: uuid!,
         $targetMemory: uuid!,
         $relationship: String!,
-        $weight: float8!,
-        $metadata: jsonb!
+        $weight: float8!
       ) {
         insert_memory_edges_one(object: {
           source_memory: $sourceMemory,
           target_memory: $targetMemory,
           relationship: $relationship,
-          weight: $weight,
-          metadata: $metadata
+          weight: $weight
         }) {
           id
           source_memory
@@ -398,23 +388,14 @@ class MeshOS {
           relationship
           weight
           created_at
-          metadata
         }
       }
     `;
-        const fullMetadata = {
-            relationship,
-            weight,
-            bidirectional: false,
-            additional: {},
-            ...metadata
-        };
         const result = await this.executeQuery(query, {
             sourceMemory: sourceMemoryId,
             targetMemory: targetMemoryId,
             relationship,
-            weight,
-            metadata: fullMetadata
+            weight
         });
         // Convert snake_case to camelCase
         const { source_memory, target_memory, created_at, ...rest } = result.insert_memory_edges_one;
@@ -484,12 +465,7 @@ class MeshOS {
         if (createVersionEdge) {
             // If we got multiple memories (chunks), link the first one
             const firstNewMemory = Array.isArray(newMemories) ? newMemories[0] : newMemories;
-            await this.linkMemories(oldMemory.id, firstNewMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0, {
-                relationship: taxonomy_1.EdgeType.VERSION_OF,
-                weight: 1.0,
-                bidirectional: false,
-                additional: { version_increment: 1 }
-            });
+            await this.linkMemories(oldMemory.id, firstNewMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0);
         }
         return newMemories;
     }

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[]>;
+}