@props-labs/mesh-os 0.1.23 → 0.2.0

package/dist/core/memories.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryManager = void 0;
+const zod_1 = require("zod");
+// Validation schemas
+const memorySchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    type: zod_1.z.string(),
+    status: zod_1.z.enum(['active', 'archived', 'deleted']),
+    metadata: zod_1.z.record(zod_1.z.any()),
+    content: zod_1.z.string(),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string(),
+    agent_id: zod_1.z.string().uuid().nullable().optional()
+});
+const memoryChunkSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    memory_id: zod_1.z.string().uuid(),
+    chunk_index: zod_1.z.number(),
+    content: zod_1.z.string(),
+    embedding: zod_1.z.array(zod_1.z.number()).optional(),
+    metadata: zod_1.z.record(zod_1.z.any()),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string(),
+    agent_id: zod_1.z.string().uuid().nullable().optional()
+});
+const typeSchemaSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    schema: zod_1.z.record(zod_1.z.any()),
+    metadata_schema: zod_1.z.record(zod_1.z.any()).nullable().optional(),
+    embedding_config: zod_1.z.object({
+        model: zod_1.z.string(),
+        dimensions: zod_1.z.number()
+    }).nullable().optional(),
+    chunking_config: zod_1.z.object({
+        chunk_size: zod_1.z.number(),
+        chunk_overlap: zod_1.z.number()
+    }).nullable().optional(),
+    validation_rules: zod_1.z.record(zod_1.z.any()).nullable().optional(),
+    behaviors: zod_1.z.record(zod_1.z.any()).nullable().optional(),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string()
+});
+class MemoryManager {
+    constructor(url, headers, createEmbedding) {
+        this.url = url;
+        this.headers = headers;
+        this.createEmbedding = createEmbedding;
+    }
+    /**
+     * 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 a memory by its ID
+     */
+    async get(id) {
+        const query = `
+      query GetMemory($id: uuid!) {
+        memories_by_pk(id: $id) {
+          id
+          type
+          status
+          metadata
+          content
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        const memory = result.memories_by_pk;
+        if (!memory) {
+            throw new Error(`Memory not found with id: ${id}`);
+        }
+        return memorySchema.parse(memory);
+    }
+    /**
+     * Get a type schema by its type name
+     */
+    async getTypeSchema(type) {
+        const query = `
+      query GetTypeSchema($type: String!) {
+        type_schemas_by_pk(type: $type) {
+          type
+          schema
+          metadata_schema
+          embedding_config
+          chunking_config
+          validation_rules
+          behaviors
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { type });
+        const typeSchema = result.type_schemas_by_pk;
+        if (!typeSchema) {
+            throw new Error(`Type schema not found for type: ${type}`);
+        }
+        return typeSchemaSchema.parse(typeSchema);
+    }
+    /**
+     * Create chunks from content based on type schema configuration
+     */
+    createChunks(content, chunkSize, chunkOverlap) {
+        const words = content.split(' ');
+        const chunks = [];
+        let currentIndex = 0;
+        while (currentIndex < words.length) {
+            const chunkWords = words.slice(currentIndex, currentIndex + chunkSize);
+            chunks.push({
+                content: chunkWords.join(' '),
+                index: chunks.length
+            });
+            currentIndex += chunkSize - chunkOverlap;
+        }
+        return chunks;
+    }
+    /**
+     * Create a new memory with chunks and embeddings
+     */
+    async create(input) {
+        // First get the type schema to validate against
+        const typeSchema = await this.getTypeSchema(input.type);
+        // Create the memory
+        const createMemoryQuery = `
+      mutation CreateMemory($memory: memories_insert_input!) {
+        insert_memories_one(object: $memory) {
+          id
+          type
+          status
+          metadata
+          content
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const memoryResult = await this.executeQuery(createMemoryQuery, {
+            memory: {
+                type: input.type,
+                content: input.content,
+                metadata: input.metadata || {},
+                status: 'active',
+                agent_id: input.agent_id
+            }
+        });
+        const memory = memoryResult.insert_memories_one;
+        // Create chunks based on type schema configuration
+        const chunkSize = typeSchema.chunking_config?.chunk_size || 1000;
+        const chunkOverlap = typeSchema.chunking_config?.chunk_overlap || 100;
+        const chunks = this.createChunks(input.content, chunkSize, chunkOverlap);
+        // Create embeddings for each chunk
+        const chunksWithEmbeddings = await Promise.all(chunks.map(async (chunk) => ({
+            ...chunk,
+            embedding: await this.createEmbedding(chunk.content)
+        })));
+        // Insert chunks
+        const createChunksQuery = `
+      mutation CreateMemoryChunks($chunks: [memory_chunks_insert_input!]!) {
+        insert_memory_chunks(objects: $chunks) {
+          affected_rows
+        }
+      }
+    `;
+        await this.executeQuery(createChunksQuery, {
+            chunks: chunksWithEmbeddings.map(chunk => ({
+                memory_id: memory.id,
+                chunk_index: chunk.index,
+                content: chunk.content,
+                embedding: `[${chunk.embedding.join(',')}]`,
+                metadata: {},
+                agent_id: input.agent_id
+            }))
+        });
+        return {
+            memory: memorySchema.parse(memory),
+            chunkCount: chunks.length
+        };
+    }
+    /**
+     * Search memories by semantic similarity using chunk embeddings
+     */
+    async search(options) {
+        const { query, threshold = 0.7, limit = 10, agentId, metadataFilter, createdAtFilter } = options;
+        // Create embedding for the query
+        const embedding = await this.createEmbedding(query);
+        // Ensure the embedding is normalized
+        const magnitude = Math.sqrt(embedding.reduce((acc, val) => acc + val * val, 0));
+        const normalizedEmbedding = embedding.map(val => val / magnitude);
+        const embeddingStr = `[${normalizedEmbedding.join(',')}]`;
+        const gqlQuery = `
+      query SearchMemoryChunks($args: search_memory_chunks_args!) {
+        search_memory_chunks(args: $args) {
+          chunk_id
+          memory_id
+          chunk_index
+          chunk_content
+          chunk_metadata
+          chunk_created_at
+          chunk_updated_at
+          memory_content
+          memory_type
+          memory_status
+          memory_metadata
+          memory_created_at
+          memory_updated_at
+          agent_id
+          similarity
+        }
+      }
+    `;
+        const result = await this.executeQuery(gqlQuery, {
+            args: {
+                query_embedding: embeddingStr,
+                match_threshold: threshold,
+                match_count: limit,
+                filter_agent_id: agentId,
+                memory_metadata_filter: metadataFilter,
+                chunk_metadata_filter: null,
+                created_at_filter: createdAtFilter
+            }
+        });
+        // Convert to SearchMemoryResult format and deduplicate by memory_id
+        // keeping the highest similarity score for each memory
+        const memoryMap = new Map();
+        for (const chunk of result.search_memory_chunks) {
+            const existing = memoryMap.get(chunk.memory_id);
+            if (!existing || chunk.similarity > existing.similarity) {
+                memoryMap.set(chunk.memory_id, {
+                    id: chunk.memory_id,
+                    type: chunk.memory_type,
+                    status: chunk.memory_status,
+                    content: chunk.memory_content,
+                    metadata: chunk.memory_metadata,
+                    created_at: chunk.memory_created_at,
+                    updated_at: chunk.memory_updated_at,
+                    agent_id: chunk.agent_id,
+                    similarity: chunk.similarity
+                });
+            }
+        }
+        // Sort by similarity and return results
+        return Array.from(memoryMap.values())
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit);
+    }
+    /**
+     * Clean up test memories and their chunks
+     */
+    async cleanup(memoryIds) {
+        if (memoryIds.length === 0)
+            return;
+        const cleanupQuery = `
+      mutation CleanupTestMemories($ids: [uuid!]!) {
+        delete_memory_chunks(where: { memory_id: { _in: $ids }}) {
+          affected_rows
+        }
+        delete_memories(where: { id: { _in: $ids }}) {
+          affected_rows
+        }
+      }
+    `;
+        await this.executeQuery(cleanupQuery, { ids: memoryIds });
+    }
+    /**
+     * Update an existing memory and optionally its chunks
+     */
+    async update(input) {
+        // First get the existing memory to validate it exists
+        const existingMemory = await this.get(input.id);
+        // Prepare update object with only changed fields
+        const updateFields = {};
+        if (input.status !== undefined)
+            updateFields.status = input.status;
+        if (input.metadata !== undefined)
+            updateFields.metadata = input.metadata;
+        if (input.content !== undefined)
+            updateFields.content = input.content;
+        // If no fields to update, return existing memory
+        if (Object.keys(updateFields).length === 0) {
+            return { memory: existingMemory };
+        }
+        // Update the memory
+        const updateMemoryQuery = `
+      mutation UpdateMemory($id: uuid!, $updates: memories_set_input!) {
+        update_memories_by_pk(pk_columns: {id: $id}, _set: $updates) {
+          id
+          type
+          status
+          metadata
+          content
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const memoryResult = await this.executeQuery(updateMemoryQuery, {
+            id: input.id,
+            updates: updateFields
+        });
+        const updatedMemory = memoryResult.update_memories_by_pk;
+        // If content was updated, we need to update chunks
+        let chunkCount;
+        if (input.content !== undefined) {
+            // Get the type schema for chunking config
+            const typeSchema = await this.getTypeSchema(updatedMemory.type);
+            const chunkSize = typeSchema.chunking_config?.chunk_size || 1000;
+            const chunkOverlap = typeSchema.chunking_config?.chunk_overlap || 100;
+            // Create new chunks
+            const chunks = this.createChunks(input.content, chunkSize, chunkOverlap);
+            // Generate embeddings for new chunks
+            const chunksWithEmbeddings = await Promise.all(chunks.map(async (chunk) => ({
+                ...chunk,
+                embedding: await this.createEmbedding(chunk.content)
+            })));
+            // Delete existing chunks
+            const deleteChunksQuery = `
+        mutation DeleteMemoryChunks($memory_id: uuid!) {
+          delete_memory_chunks(where: {memory_id: {_eq: $memory_id}}) {
+            affected_rows
+          }
+        }
+      `;
+            await this.executeQuery(deleteChunksQuery, { memory_id: input.id });
+            // Insert new chunks
+            const createChunksQuery = `
+        mutation CreateMemoryChunks($chunks: [memory_chunks_insert_input!]!) {
+          insert_memory_chunks(objects: $chunks) {
+            affected_rows
+          }
+        }
+      `;
+            await this.executeQuery(createChunksQuery, {
+                chunks: chunksWithEmbeddings.map(chunk => ({
+                    memory_id: updatedMemory.id,
+                    chunk_index: chunk.index,
+                    content: chunk.content,
+                    embedding: `[${chunk.embedding.join(',')}]`,
+                    metadata: {},
+                    agent_id: updatedMemory.agent_id
+                }))
+            });
+            chunkCount = chunks.length;
+        }
+        return {
+            memory: memorySchema.parse(updatedMemory),
+            chunkCount
+        };
+    }
+    /**
+     * Mark a memory as deleted
+     */
+    async delete(id) {
+        return (await this.update({
+            id,
+            status: 'deleted'
+        })).memory;
+    }
+    /**
+     * Mark a memory as archived
+     */
+    async archive(id) {
+        return (await this.update({
+            id,
+            status: 'archived'
+        })).memory;
+    }
+    /**
+     * List all available type schemas
+     */
+    async listSchemas() {
+        const query = `
+      query ListTypeSchemas {
+        type_schemas {
+          type
+          schema
+          metadata_schema
+          embedding_config
+          chunking_config
+          validation_rules
+          behaviors
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {});
+        return result.type_schemas.map(schema => typeSchemaSchema.parse(schema));
+    }
+}
+exports.MemoryManager = MemoryManager;

package/dist/core/workflows.d.ts

@@ -1,45 +1,104 @@
-/**
- * Workflow management functionality for MeshOS.
- */
-import { Workflow } from './taxonomy';
+export interface WorkflowSchema {
+    type: string;
+    input_schema: Record<string, any>;
+    output_schema: Record<string, any>;
+    metadata_schema?: Record<string, any> | null;
+    validation_rules?: Record<string, any> | null;
+    behaviors?: Record<string, any> | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface WorkflowRun {
+    id: string;
+    type: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    input: Record<string, any>;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string | null;
+}
+export interface WorkflowResult {
+    id: string;
+    workflow_id: string;
+    type: 'interim' | 'final';
+    result: Record<string, any>;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string | null;
+}
+export interface CreateWorkflowRunInput {
+    type: string;
+    input: Record<string, any>;
+    metadata?: Record<string, any>;
+    agent_id?: string;
+}
+export interface UpdateWorkflowStatusInput {
+    id: string;
+    status: WorkflowRun['status'];
+    metadata?: Record<string, any>;
+}
+export interface CreateWorkflowResultInput {
+    workflow_id: string;
+    type: WorkflowResult['type'];
+    result: Record<string, any>;
+    metadata?: Record<string, any>;
+    agent_id?: string;
+}
+export interface ListWorkflowRunsOptions {
+    type?: string;
+    status?: WorkflowRun['status'];
+    agent_id?: string;
+    limit?: number;
+    offset?: number;
+    order_by?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
 export declare class WorkflowManager {
     private url;
     private headers;
     constructor(url: string, headers: Record<string, string>);
     /**
-     * Execute a GraphQL query.
+     * Execute a GraphQL query against Hasura
      */
     private executeQuery;
     /**
-     * Get a workflow by job ID.
+     * List available workflow schemas
+     */
+    listSchemas(): Promise<WorkflowSchema[]>;
+    /**
+     * Get a workflow schema by type
+     */
+    getSchema(type: string): Promise<WorkflowSchema>;
+    /**
+     * Create a new workflow run
+     */
+    createRun(input: CreateWorkflowRunInput): Promise<WorkflowRun>;
+    /**
+     * Update a workflow run's status
      */
-    getByJobId(jobId: string): Promise<Workflow | null>;
+    updateStatus(input: UpdateWorkflowStatusInput): Promise<WorkflowRun>;
     /**
-     * Create a new workflow.
+     * Create a workflow result
      */
-    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow>;
+    createResult(input: CreateWorkflowResultInput): Promise<WorkflowResult>;
     /**
-     * Get a workflow by ID.
+     * Get a workflow run by ID
      */
-    get(id: string): Promise<Workflow | null>;
+    getRun(id: string): Promise<WorkflowRun>;
     /**
-     * Get workflows with optional filtering and sorting.
+     * Get all results for a workflow run
      */
-    list(options?: {
-        where?: Record<string, unknown>;
-        orderBy?: Array<{
-            column: string;
-            order: 'asc' | 'desc';
-        }>;
-        limit?: number;
-        offset?: number;
-    }): Promise<Workflow[]>;
+    getResults(workflowId: string): Promise<WorkflowResult[]>;
     /**
-     * Update a workflow.
+     * Get the final result for a workflow run
      */
-    update(id: string, updates: Partial<Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>>): Promise<Workflow>;
+    getFinalResult(workflowId: string): Promise<WorkflowResult | null>;
     /**
-     * Delete a workflow.
+     * List workflow runs with optional filtering and sorting
      */
-    delete(id: string): Promise<boolean>;
+    listRuns(options?: ListWorkflowRunsOptions): Promise<WorkflowRun[]>;
 }