@props-labs/mesh-os 0.1.23 → 0.2.0

package/src/templates/hasura/migrations/default/3_agent_relations/up.sql

@@ -0,0 +1,469 @@
+-- Create agents table
+CREATE TABLE IF NOT EXISTS agents (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    slug TEXT UNIQUE,
+    name TEXT,
+    description TEXT,
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create trigger for agents updated_at
+CREATE TRIGGER update_agents_updated_at
+    BEFORE UPDATE ON agents
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Drop views that depend on memories table
+DROP VIEW IF EXISTS memory_chunks_with_details CASCADE;
+DROP VIEW IF EXISTS memory_search_results CASCADE;
+
+-- Add agent_id to memories
+ALTER TABLE memories 
+ADD COLUMN agent_id UUID REFERENCES agents(id) ON DELETE SET NULL;
+
+-- Add agent_id to memory_chunks
+ALTER TABLE memory_chunks 
+ADD COLUMN agent_id UUID REFERENCES agents(id) ON DELETE SET NULL;
+
+-- Add agent_id to memory_edges
+ALTER TABLE memory_edges 
+ADD COLUMN agent_id UUID REFERENCES agents(id) ON DELETE SET NULL;
+
+-- Add agent_id to workflow_runs
+ALTER TABLE workflow_runs 
+ADD COLUMN agent_id UUID REFERENCES agents(id) ON DELETE SET NULL;
+
+-- Add agent_id to workflow_results
+ALTER TABLE workflow_results 
+ADD COLUMN agent_id UUID REFERENCES agents(id) ON DELETE SET NULL;
+
+-- Recreate the view with agent_id support
+CREATE OR REPLACE VIEW memory_chunks_with_details AS
+SELECT 
+    mc.id as chunk_id,
+    mc.memory_id,
+    mc.chunk_index,
+    mc.content as chunk_content,
+    mc.embedding,
+    mc.metadata as chunk_metadata,
+    mc.created_at as chunk_created_at,
+    mc.updated_at as chunk_updated_at,
+    m.content as memory_content,
+    m.type as memory_type,
+    m.status as memory_status,
+    m.metadata as memory_metadata,
+    m.created_at as memory_created_at,
+    m.updated_at as memory_updated_at,
+    m.agent_id
+FROM memory_chunks mc
+JOIN memories m ON mc.memory_id = m.id;
+
+-- Create view for search results
+CREATE OR REPLACE VIEW memory_search_results AS
+SELECT 
+    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,
+    0.0::float as similarity
+FROM memory_chunks_with_details
+WHERE false;  -- Empty by default, will be populated by function
+
+-- Create search function
+CREATE OR REPLACE FUNCTION search_memory_chunks(
+    query_embedding vector,
+    match_threshold double precision,
+    match_count integer,
+    filter_agent_id uuid DEFAULT NULL::uuid,
+    memory_metadata_filter jsonb DEFAULT NULL::jsonb,
+    chunk_metadata_filter jsonb DEFAULT NULL::jsonb,
+    created_at_filter jsonb DEFAULT NULL::jsonb
+)
+RETURNS SETOF memory_search_results
+LANGUAGE sql STABLE AS $$
+    WITH normalized_query AS (
+        SELECT l2_normalize(query_embedding) AS normalized_vector
+    )
+    SELECT
+        cd.chunk_id,
+        cd.memory_id,
+        cd.chunk_index,
+        cd.chunk_content,
+        cd.chunk_metadata,
+        cd.chunk_created_at,
+        cd.chunk_updated_at,
+        cd.memory_content,
+        cd.memory_type,
+        cd.memory_status,
+        cd.memory_metadata,
+        cd.memory_created_at,
+        cd.memory_updated_at,
+        cd.agent_id,
+        -(cd.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+    FROM memory_chunks_with_details cd
+    WHERE
+        CASE
+            WHEN filter_agent_id IS NOT NULL THEN cd.agent_id = filter_agent_id
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN memory_metadata_filter IS NOT NULL THEN cd.memory_metadata @> memory_metadata_filter
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN chunk_metadata_filter IS NOT NULL THEN cd.chunk_metadata @> chunk_metadata_filter
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN created_at_filter IS NOT NULL THEN (
+                CASE
+                    WHEN created_at_filter ? '_gt' THEN cd.chunk_created_at > (created_at_filter->>'_gt')::timestamptz AT TIME ZONE 'UTC'
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_gte' THEN cd.chunk_created_at >= (created_at_filter->>'_gte')::timestamptz AT TIME ZONE 'UTC'
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lt' THEN cd.chunk_created_at < (created_at_filter->>'_lt')::timestamptz AT TIME ZONE 'UTC'
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lte' THEN cd.chunk_created_at <= (created_at_filter->>'_lte')::timestamptz AT TIME ZONE 'UTC'
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_eq' THEN cd.chunk_created_at = (created_at_filter->>'_eq')::timestamptz AT TIME ZONE 'UTC'
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_is_null' AND (created_at_filter->>'_is_null')::boolean THEN cd.chunk_created_at IS NULL
+                    WHEN created_at_filter ? '_is_null' AND NOT (created_at_filter->>'_is_null')::boolean THEN cd.chunk_created_at IS NOT NULL
+                    ELSE TRUE
+                END
+            )
+            ELSE TRUE
+        END
+        AND cd.embedding IS NOT NULL
+        AND -(cd.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    ORDER BY
+        -(cd.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
+    LIMIT match_count;
+$$;
+
+-- Create indexes for agent_id fields
+CREATE INDEX idx_memories_agent_id ON memories(agent_id);
+CREATE INDEX idx_memory_chunks_agent_id ON memory_chunks(agent_id);
+CREATE INDEX idx_memory_edges_agent_id ON memory_edges(agent_id);
+CREATE INDEX idx_workflow_runs_agent_id ON workflow_runs(agent_id);
+CREATE INDEX idx_workflow_results_agent_id ON workflow_results(agent_id);
+
+-- Add helpful comments
+COMMENT ON TABLE agents IS 
+'Agents that can own and interact with memories and workflows.';
+
+COMMENT ON COLUMN agents.name IS 
+'Optional name for the agent.';
+
+COMMENT ON COLUMN agents.description IS 
+'Optional description of the agent''s purpose or capabilities.';
+
+COMMENT ON COLUMN agents.slug IS 
+'Unique identifier string for the agent, URL-friendly format.';
+
+COMMENT ON COLUMN memories.agent_id IS 
+'Reference to the agent that owns or created this memory.';
+
+COMMENT ON COLUMN memory_chunks.agent_id IS 
+'Reference to the agent that owns or created this memory chunk.';
+
+COMMENT ON COLUMN memory_edges.agent_id IS 
+'Reference to the agent that created this relationship.';
+
+COMMENT ON COLUMN workflow_runs.agent_id IS 
+'Reference to the agent that initiated this workflow run.';
+
+COMMENT ON COLUMN workflow_results.agent_id IS 
+'Reference to the agent that owns this workflow result.';
+
+-- Insert sample agent and data
+INSERT INTO agents (id, slug, name, description) VALUES 
+('d7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid, 'test-agent', 'TestAgent', 'A test agent for development and examples');
+
+-- Insert sample memories and their chunks
+WITH text_memory AS (
+    INSERT INTO memories (id, type, content, metadata, agent_id) VALUES
+    ('f7a6c2b1-d123-4567-8901-2345abcdef67'::uuid, 
+     'text_document', 
+     'The quick brown fox jumps over the lazy dog. This classic pangram contains every letter of the English alphabet at least once.',
+     jsonb_build_object(
+        'source', 'example_docs',
+        'tags', array['pangram', 'example']
+     ),
+     'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+    ) RETURNING id, content
+),
+code_memory AS (
+    INSERT INTO memories (id, type, content, metadata, agent_id) VALUES
+    ('e8b7d3c2-e234-5678-9012-3456bcdef789'::uuid,
+     'code_snippet',
+     'def fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)',
+     jsonb_build_object(
+        'repository', 'algorithms',
+        'path', 'math/fibonacci.py',
+        'tags', array['python', 'recursion']
+     ),
+     'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+    ) RETURNING id, content
+)
+-- Insert memory chunks with sample embeddings
+INSERT INTO memory_chunks (id, memory_id, chunk_index, content, embedding, metadata, agent_id)
+SELECT 
+    'a1b2c3d4-1234-5678-90ab-cdef12345678'::uuid,
+    id,
+    0,
+    content,
+    l2_normalize((
+        SELECT array_agg(val)::vector
+        FROM (
+            SELECT 
+                CASE 
+                    WHEN n <= 512 THEN 0.8 + random() * 0.4  -- Higher values for first third
+                    WHEN n <= 1024 THEN 0.4 + random() * 0.4  -- Medium values for middle third
+                    ELSE random() * 0.4  -- Lower values for last third
+                END as val
+            FROM generate_series(1, 1536) n
+        ) vals
+    )),  -- Use l2_normalize directly
+    jsonb_build_object(
+        'chunk_type', 'full',
+        'embedding_model', 'text-embedding-3-small',
+        'embedding_created_at', CURRENT_TIMESTAMP
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+FROM text_memory
+UNION ALL
+SELECT 
+    'b2c3d4e5-2345-6789-01bc-def234567890'::uuid,
+    id,
+    0,
+    content,
+    l2_normalize((
+        SELECT array_agg(val)::vector
+        FROM (
+            SELECT 
+                CASE 
+                    WHEN n <= 512 THEN random() * 0.4  -- Lower values for first third
+                    WHEN n <= 1024 THEN 0.6 + random() * 0.4  -- Higher values for middle third
+                    ELSE 0.3 + random() * 0.4  -- Medium values for last third
+                END as val
+            FROM generate_series(1, 1536) n
+        ) vals
+    )),  -- Use l2_normalize directly
+    jsonb_build_object(
+        'chunk_type', 'full',
+        'embedding_model', 'text-embedding-3-small',
+        'embedding_created_at', CURRENT_TIMESTAMP
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+FROM code_memory;
+
+-- Insert sample workflow runs and results
+WITH inserted_run AS (
+    INSERT INTO workflow_runs (id, type, status, input, metadata, agent_id) VALUES
+    ('c4d5e6f7-3456-7890-12cd-ef3456789012'::uuid,
+     'document_analysis',
+     'completed',
+     jsonb_build_object(
+        'document_id', 'f7a6c2b1-d123-4567-8901-2345abcdef67',
+        'analysis_type', 'summary'
+     ),
+     jsonb_build_object(
+        'model_version', '1.0.0',
+        'processing_time', 0.5
+     ),
+     'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+    ) RETURNING id
+)
+INSERT INTO workflow_results (id, workflow_id, type, result, metadata, agent_id) VALUES
+(
+    'd5e6f7f8-4567-8901-23de-f45678901234'::uuid,
+    (SELECT id FROM inserted_run),
+    'interim',
+    jsonb_build_object(
+        'initial_analysis', 'Text contains all English alphabet letters in a single sentence.',
+        'confidence', 0.85
+    ),
+    jsonb_build_object(
+        'completion_time', CURRENT_TIMESTAMP - interval '2 seconds',
+        'tokens_processed', 8,
+        'stage', 'initial_analysis'
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+),
+(
+    'd5e6f7f8-4567-8901-23de-f45678901235'::uuid,
+    (SELECT id FROM inserted_run),
+    'final',
+    jsonb_build_object(
+        'summary', 'A pangram demonstrating all English alphabet letters.',
+        'confidence', 0.95
+    ),
+    jsonb_build_object(
+        'completion_time', CURRENT_TIMESTAMP,
+        'tokens_processed', 15,
+        'stage', 'final_summary'
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+);
+
+-- Create relationships between memories
+INSERT INTO memory_edges (id, source_memory, target_memory, type, metadata, weight, agent_id)
+SELECT 
+    'e6f7a8a9-5678-9012-34ef-a56789012345'::uuid,
+    m1.id,
+    m2.id,
+    'related_content',
+    jsonb_build_object(
+        'relationship_type', 'example',
+        'created_by', 'system'
+    ),
+    0.8,
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+FROM memories m1
+JOIN memories m2 ON m1.type = 'text_document' AND m2.type = 'code_snippet';
+
+-- Insert sample thought memories
+WITH thought_memory AS (
+    INSERT INTO memories (id, type, content, metadata, agent_id) VALUES
+    ('a9b8c7d6-f123-4567-8901-234567890abc'::uuid,
+     'thought',
+     'AI agents could revolutionize personal productivity by learning from our digital traces and automating routine tasks.',
+     jsonb_build_object(
+        'context', 'Reading about AI agent architectures',
+        'tags', array['ai', 'productivity', 'agents'],
+        'confidence', 0.85,
+        'links', array[
+            jsonb_build_object(
+                'url', 'https://example.com/ai-agents',
+                'title', 'The Future of AI Agents',
+                'description', 'Research paper on AI agent architectures'
+            )
+        ]
+     ),
+     'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+    ) RETURNING id, content
+)
+-- Insert thought memory chunks
+INSERT INTO memory_chunks (id, memory_id, chunk_index, content, embedding, metadata, agent_id)
+SELECT 
+    'f1e2d3c4-9876-5432-10fe-dcba09876543'::uuid,
+    id,
+    0,
+    content,
+    l2_normalize((
+        SELECT array_agg(val)::vector
+        FROM (
+            SELECT 
+                CASE 
+                    WHEN n <= 512 THEN 0.7 + random() * 0.3  -- Higher values for concepts
+                    WHEN n <= 1024 THEN 0.5 + random() * 0.3  -- Medium values for context
+                    ELSE 0.2 + random() * 0.3  -- Lower values for details
+                END as val
+            FROM generate_series(1, 1536) n
+        ) vals
+    )),
+    jsonb_build_object(
+        'chunk_type', 'full',
+        'embedding_model', 'text-embedding-3-small',
+        'embedding_created_at', CURRENT_TIMESTAMP
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+FROM thought_memory;
+
+-- Insert sample thread generation workflow
+WITH thread_run AS (
+    INSERT INTO workflow_runs (id, type, status, input, metadata, agent_id) VALUES
+    ('b1c2d3e4-5678-9012-34ef-567890123456'::uuid,
+     'twitter_thread_generator',
+     'completed',
+     jsonb_build_object(
+        'content', 'AI agents are revolutionizing productivity. Here''s how they learn from our digital footprints to automate tasks and enhance our workflow...',
+        'links', array['https://example.com/ai-agents'],
+        'use_deep_research', true
+     ),
+     jsonb_build_object(
+        'generation_model', 'gpt-4',
+        'research_depth', 3,
+        'processing_time', 12.5
+     ),
+     'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+    ) RETURNING id
+)
+INSERT INTO workflow_results (id, workflow_id, type, result, metadata, agent_id) VALUES
+(
+    'c2d3e4f5-6789-0123-45fa-678901234566'::uuid,
+    (SELECT id FROM thread_run),
+    'interim',
+    jsonb_build_object(
+        'outline', array[
+            'Introduction to AI agents and productivity',
+            'Key benefits and features',
+            'Technical explanation',
+            'Future implications and call to action'
+        ],
+        'research_findings', jsonb_build_object(
+            'key_concepts', array['automation', 'personalization', 'learning', 'optimization'],
+            'supporting_data', 'Initial research suggests 40% productivity gains possible'
+        )
+    ),
+    jsonb_build_object(
+        'completion_time', CURRENT_TIMESTAMP - interval '5 seconds',
+        'tokens_processed', 180,
+        'stage', 'research_and_outline'
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+),
+(
+    'c2d3e4f5-6789-0123-45fa-678901234567'::uuid,
+    (SELECT id FROM thread_run),
+    'final',
+    jsonb_build_object(
+        'posts', array[
+            jsonb_build_object(
+                'text', '🤖 AI agents are revolutionizing how we work! They''re like digital assistants that learn from our habits and automate the boring stuff. Here''s a thread on how they''re changing the game... 1/4',
+                'media_type', 'image',
+                'media_url', 'https://example.com/images/ai-agent-banner.jpg'
+            ),
+            jsonb_build_object(
+                'text', '📊 Key benefits of AI agents:\n\n• Learn from your digital footprint\n• Automate repetitive tasks\n• Adapt to your workflow\n• Provide personalized assistance\n\nThey''re not just tools, they''re partners in productivity! 2/4'
+            ),
+            jsonb_build_object(
+                'text', '🔍 The science behind it:\n\nAI agents use advanced machine learning to understand your patterns and preferences. They analyze your interactions and optimize their assistance over time. 3/4',
+                'media_type', 'gif',
+                'media_url', 'https://example.com/gifs/ai-learning.gif'
+            ),
+            jsonb_build_object(
+                'text', '🚀 The future is here! AI agents are becoming more sophisticated every day. Soon, they''ll be essential for anyone looking to maximize their productivity.\n\nWant to learn more? Check out this research: https://example.com/ai-agents 4/4'
+            )
+        ]
+    ),
+    jsonb_build_object(
+        'completion_time', CURRENT_TIMESTAMP,
+        'tokens_processed', 450,
+        'engagement_score', 0.92,
+        'stage', 'final_thread'
+    ),
+    'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62'::uuid
+); 

package/src/templates/hasura/metadata/config.yaml

@@ -1 +0,0 @@
- 

package/src/templates/hasura/metadata/databases/default/tables/public_agents.yaml

@@ -1,14 +0,0 @@
-table:
-  name: agents
-  schema: public
-configuration:
-  custom_root_fields: {}
-  custom_name: agents
-array_relationships:
-  - name: memories
-    using:
-      foreign_key_constraint_on:
-        column: agent_id
-        table:
-          name: memories
-          schema: public 

package/src/templates/hasura/metadata/databases/default/tables/public_memories.yaml

@@ -1,23 +0,0 @@
-table:
-  name: memories
-  schema: public
-configuration:
-  custom_root_fields: {}
-  custom_name: memories
-object_relationships:
-  - name: agent
-    using:
-      foreign_key_constraint_on: agent_id
-computed_fields:
-  - name: similarity_score
-    definition:
-      function:
-        name: search_memories
-        schema: public
-        arguments:
-          query_embedding: $query_embedding
-          match_threshold: $match_threshold
-          match_count: $match_count
-          filter_agent_id: $filter_agent_id
-          metadata_filter: $metadata_filter
-    comment: Computes similarity score for vector search 

package/src/templates/hasura/metadata/databases/default/tables/public_memory_edges.yaml

@@ -1,57 +0,0 @@
-table:
-  name: memory_edges
-  schema: public
-is_enum: false
-configuration:
-  column_config: {}
-  custom_column_names: {}
-  custom_name: memory_edges
-  custom_root_fields: {}
-
-array_relationships: []
-computed_fields: []
-delete_permissions:
-  - role: admin
-    permission:
-      filter: {}
-
-event_triggers: []
-insert_permissions:
-  - role: admin
-    permission:
-      check: {}
-      columns:
-        - id
-        - source_memory
-        - target_memory
-        - relationship
-        - weight
-        - created_at
-
-object_relationships:
-  - name: source
-    using:
-      foreign_key_constraint_on: source_memory
-  - name: target
-    using:
-      foreign_key_constraint_on: target_memory
-
-select_permissions:
-  - role: admin
-    permission:
-      columns:
-        - id
-        - source_memory
-        - target_memory
-        - relationship
-        - weight
-        - created_at
-      filter: {}
-
-update_permissions:
-  - role: admin
-    permission:
-      columns:
-        - weight
-      filter: {}
-      check: {} 

package/src/templates/hasura/metadata/databases/default/tables/track_tables.yaml

@@ -1,14 +0,0 @@
-- table:
-    schema: public
-    name: agents
-  is_enum: false
-
-- table:
-    schema: public
-    name: memories
-  is_enum: false
-
-- table:
-    schema: public
-    name: memory_edges
-  is_enum: false 

package/src/templates/hasura/metadata/metadata.json

@@ -1,80 +0,0 @@
-{
-  "version": 3,
-  "sources": [
-    {
-      "name": "default",
-      "kind": "postgres",
-      "tables": [
-        {
-          "table": {
-            "schema": "public",
-            "name": "agents"
-          },
-          "array_relationships": [
-            {
-              "name": "memories",
-              "using": {
-                "foreign_key_constraint_on": {
-                  "column": "agent_id",
-                  "table": {
-                    "schema": "public",
-                    "name": "memories"
-                  }
-                }
-              }
-            }
-          ]
-        },
-        {
-          "table": {
-            "schema": "public",
-            "name": "memories"
-          },
-          "object_relationships": [
-            {
-              "name": "agent",
-              "using": {
-                "foreign_key_constraint_on": "agent_id"
-              }
-            }
-          ],
-          "computed_fields": [
-            {
-              "name": "similarity_score",
-              "definition": {
-                "function": {
-                  "schema": "public",
-                  "name": "search_memories"
-                }
-              },
-              "comment": "Computes similarity score for vector search"
-            }
-          ]
-        }
-      ],
-      "functions": [
-        {
-          "function": {
-            "schema": "public",
-            "name": "search_memories"
-          }
-        }
-      ],
-      "configuration": {
-        "connection_info": {
-          "use_prepared_statements": true,
-          "database_url": {
-            "from_env": "HASURA_GRAPHQL_DATABASE_URL"
-          },
-          "isolation_level": "read-committed",
-          "pool_settings": {
-            "connection_lifetime": 600,
-            "retries": 1,
-            "idle_timeout": 180,
-            "max_connections": 50
-          }
-        }
-      }
-    }
-  ]
-} 

package/src/templates/hasura/migrations/default/2_metadata_filtering/down.sql

@@ -1,4 +0,0 @@
--- Drop the updated search_memories function with metadata filtering
-DROP FUNCTION public.search_memories(vector(1536), float8, integer, uuid, jsonb);
-
--- Note: The original search_memories function from 1_init will be restored when that migration is reapplied