@props-labs/mesh-os 0.1.23 → 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/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[]>;
+}