@props-labs/mesh-os 0.1.23 → 0.2.0

package/dist/core/workflows.js

@@ -4,240 +4,329 @@ exports.WorkflowManager = void 0;
 /**
  * Workflow management functionality for MeshOS.
  */
-const taxonomy_1 = require("./taxonomy");
+const zod_1 = require("zod");
+// Validation schemas
+const workflowSchemaSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    input_schema: zod_1.z.record(zod_1.z.any()),
+    output_schema: zod_1.z.record(zod_1.z.any()),
+    metadata_schema: zod_1.z.record(zod_1.z.any()).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()
+});
+const workflowRunSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    type: zod_1.z.string(),
+    status: zod_1.z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']),
+    input: zod_1.z.record(zod_1.z.any()),
+    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 workflowResultSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    workflow_id: zod_1.z.string().uuid(),
+    type: zod_1.z.enum(['interim', 'final']),
+    result: zod_1.z.record(zod_1.z.any()),
+    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()
+});
 class WorkflowManager {
     constructor(url, headers) {
         this.url = url;
         this.headers = headers;
     }
     /**
-     * Execute a GraphQL query.
+     * Execute a GraphQL query against Hasura
      */
     async executeQuery(query, variables) {
         const response = await fetch(this.url, {
             method: 'POST',
-            headers: this.headers,
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers
+            },
             body: JSON.stringify({
                 query,
-                variables: variables || {}
+                variables
             })
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            throw new Error(`Failed to execute query: ${response.statusText}`);
         }
-        const result = await response.json();
+        const result = (await response.json());
         if (result.errors) {
-            throw new Error(result.errors[0].message);
+            throw new Error(`GraphQL error: ${result.errors[0].message}`);
         }
         return result.data;
     }
     /**
-     * Get a workflow by job ID.
+     * List available workflow schemas
      */
-    async getByJobId(jobId) {
+    async listSchemas() {
         const query = `
-      query GetWorkflowByJobId($jobId: String!) {
-        workflows(where: {job_id: {_eq: $jobId}}, limit: 1) {
+      query ListWorkflowSchemas {
+        workflow_schemas {
+          type
+          input_schema
+          output_schema
+          metadata_schema
+          validation_rules
+          behaviors
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {});
+        return result.workflow_schemas.map(schema => workflowSchemaSchema.parse(schema));
+    }
+    /**
+     * Get a workflow schema by type
+     */
+    async getSchema(type) {
+        const query = `
+      query GetWorkflowSchema($type: String!) {
+        workflow_schemas_by_pk(type: $type) {
+          type
+          input_schema
+          output_schema
+          metadata_schema
+          validation_rules
+          behaviors
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { type });
+        const schema = result.workflow_schemas_by_pk;
+        if (!schema) {
+            throw new Error(`Workflow schema not found for type: ${type}`);
+        }
+        return workflowSchemaSchema.parse(schema);
+    }
+    /**
+     * Create a new workflow run
+     */
+    async createRun(input) {
+        // First get the workflow schema to validate input
+        const schema = await this.getSchema(input.type);
+        const query = `
+      mutation CreateWorkflowRun($run: workflow_runs_insert_input!) {
+        insert_workflow_runs_one(object: $run) {
           id
-          job_id
           type
           status
-          result
+          input
           metadata
           created_at
           updated_at
+          agent_id
         }
       }
     `;
-        const result = await this.executeQuery(query, { jobId });
-        if (!result.workflows[0]) {
-            return null;
-        }
-        // Convert snake_case to camelCase
-        const { job_id, created_at, updated_at, ...rest } = result.workflows[0];
-        return {
-            ...rest,
-            jobId: job_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
+        const result = await this.executeQuery(query, {
+            run: {
+                type: input.type,
+                input: input.input,
+                metadata: input.metadata || {},
+                status: 'pending',
+                agent_id: input.agent_id
+            }
+        });
+        return workflowRunSchema.parse(result.insert_workflow_runs_one);
     }
     /**
-     * Create a new workflow.
+     * Update a workflow run's status
      */
-    async create(workflow) {
-        // Validate workflow data
-        const validatedData = taxonomy_1.workflowSchema.omit({ id: true, createdAt: true, updatedAt: true }).parse(workflow);
+    async updateStatus(input) {
         const query = `
-      mutation CreateWorkflow($workflow: workflows_insert_input!) {
-        insert_workflows_one(object: $workflow) {
+      mutation UpdateWorkflowStatus($id: uuid!, $status: String!, $metadata: jsonb) {
+        update_workflow_runs_by_pk(
+          pk_columns: {id: $id}, 
+          _set: {
+            status: $status,
+            metadata: $metadata
+          }
+        ) {
           id
-          job_id
           type
           status
+          input
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            id: input.id,
+            status: input.status,
+            metadata: input.metadata
+        });
+        return workflowRunSchema.parse(result.update_workflow_runs_by_pk);
+    }
+    /**
+     * Create a workflow result
+     */
+    async createResult(input) {
+        const query = `
+      mutation CreateWorkflowResult($result: workflow_results_insert_input!) {
+        insert_workflow_results_one(object: $result) {
+          id
+          workflow_id
+          type
           result
           metadata
           created_at
           updated_at
+          agent_id
         }
       }
     `;
         const result = await this.executeQuery(query, {
-            workflow: {
-                job_id: validatedData.jobId,
-                type: validatedData.type,
-                status: validatedData.status,
-                result: validatedData.result,
-                metadata: validatedData.metadata
+            result: {
+                workflow_id: input.workflow_id,
+                type: input.type,
+                result: input.result,
+                metadata: input.metadata || {},
+                agent_id: input.agent_id
             }
         });
-        // Convert snake_case to camelCase
-        const { job_id, created_at, updated_at, ...rest } = result.insert_workflows_one;
-        return {
-            ...rest,
-            jobId: job_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
+        return workflowResultSchema.parse(result.insert_workflow_results_one);
     }
     /**
-     * Get a workflow by ID.
+     * Get a workflow run by ID
      */
-    async get(id) {
+    async getRun(id) {
         const query = `
-      query GetWorkflow($id: uuid!) {
-        workflows_by_pk(id: $id) {
+      query GetWorkflowRun($id: uuid!) {
+        workflow_runs_by_pk(id: $id) {
           id
-          job_id
           type
           status
-          result
+          input
           metadata
           created_at
           updated_at
+          agent_id
         }
       }
     `;
         const result = await this.executeQuery(query, { id });
-        if (!result.workflows_by_pk) {
-            return null;
+        const run = result.workflow_runs_by_pk;
+        if (!run) {
+            throw new Error(`Workflow run not found with id: ${id}`);
         }
-        // Convert snake_case to camelCase
-        const { job_id, created_at, updated_at, ...rest } = result.workflows_by_pk;
-        return {
-            ...rest,
-            jobId: job_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
+        return workflowRunSchema.parse(run);
     }
     /**
-     * Get workflows with optional filtering and sorting.
+     * Get all results for a workflow run
      */
-    async list(options = {}) {
-        const { where, orderBy = [{ column: 'createdAt', order: 'desc' }], limit, offset } = options;
-        // Convert orderBy to Hasura format
-        const hasuraOrderBy = orderBy.map(({ column, order }) => {
-            // Convert camelCase to snake_case for column names
-            const snakeCaseColumn = column.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-            return { [snakeCaseColumn]: order };
-        });
+    async getResults(workflowId) {
         const query = `
-      query GetWorkflows(
-        $where: workflows_bool_exp,
-        $orderBy: [workflows_order_by!],
-        $limit: Int,
-        $offset: Int
-      ) {
-        workflows(
-          where: $where,
-          order_by: $orderBy,
-          limit: $limit,
-          offset: $offset
+      query GetWorkflowResults($workflow_id: uuid!) {
+        workflow_results(
+          where: {workflow_id: {_eq: $workflow_id}}
+          order_by: {created_at: asc}
         ) {
           id
-          job_id
+          workflow_id
           type
-          status
           result
           metadata
           created_at
           updated_at
+          agent_id
         }
       }
     `;
-        const result = await this.executeQuery(query, {
-            where,
-            orderBy: hasuraOrderBy,
-            limit,
-            offset
-        });
-        return result.workflows.map(workflow => {
-            const { job_id, created_at, updated_at, ...rest } = workflow;
-            return {
-                ...rest,
-                jobId: job_id,
-                createdAt: created_at,
-                updatedAt: updated_at,
-            };
-        });
+        const result = await this.executeQuery(query, { workflow_id: workflowId });
+        return result.workflow_results.map(r => workflowResultSchema.parse(r));
     }
     /**
-     * Update a workflow.
+     * Get the final result for a workflow run
      */
-    async update(id, updates) {
+    async getFinalResult(workflowId) {
         const query = `
-      mutation UpdateWorkflow($id: uuid!, $updates: workflows_set_input!) {
-        update_workflows_by_pk(pk_columns: {id: $id}, _set: $updates) {
+      query GetWorkflowFinalResult($workflow_id: uuid!) {
+        workflow_results(
+          where: {
+            workflow_id: {_eq: $workflow_id},
+            type: {_eq: "final"}
+          }
+          limit: 1
+          order_by: {created_at: desc}
+        ) {
           id
-          job_id
+          workflow_id
           type
-          status
           result
           metadata
           created_at
           updated_at
+          agent_id
         }
       }
     `;
-        // Convert camelCase to snake_case for update fields
-        const updateData = {};
-        if (updates.jobId !== undefined)
-            updateData.job_id = updates.jobId;
-        if (updates.type !== undefined)
-            updateData.type = updates.type;
-        if (updates.status !== undefined)
-            updateData.status = updates.status;
-        if (updates.result !== undefined)
-            updateData.result = updates.result;
-        if (updates.metadata !== undefined)
-            updateData.metadata = updates.metadata;
-        const result = await this.executeQuery(query, {
-            id,
-            updates: updateData
-        });
-        // Convert snake_case to camelCase
-        const { job_id, created_at, updated_at, ...rest } = result.update_workflows_by_pk;
-        return {
-            ...rest,
-            jobId: job_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
+        const result = await this.executeQuery(query, { workflow_id: workflowId });
+        return result.workflow_results[0] ? workflowResultSchema.parse(result.workflow_results[0]) : null;
     }
     /**
-     * Delete a workflow.
+     * List workflow runs with optional filtering and sorting
      */
-    async delete(id) {
+    async listRuns(options = {}) {
+        const { type, status, agent_id, limit = 10, offset = 0, order_by = [{ field: 'created_at', direction: 'desc' }] } = options;
+        // Build where clause
+        const where = {};
+        if (type)
+            where.type = { _eq: type };
+        if (status)
+            where.status = { _eq: status };
+        if (agent_id)
+            where.agent_id = { _eq: agent_id };
+        // Convert order_by to Hasura format
+        const orderBy = order_by.map(({ field, direction }) => ({
+            [field]: direction
+        }));
         const query = `
-      mutation DeleteWorkflow($id: uuid!) {
-        delete_workflows_by_pk(id: $id) {
+      query ListWorkflowRuns(
+        $where: workflow_runs_bool_exp!,
+        $limit: Int!,
+        $offset: Int!,
+        $order_by: [workflow_runs_order_by!]!
+      ) {
+        workflow_runs(
+          where: $where,
+          limit: $limit,
+          offset: $offset,
+          order_by: $order_by
+        ) {
           id
+          type
+          status
+          input
+          metadata
+          created_at
+          updated_at
+          agent_id
         }
       }
     `;
-        const result = await this.executeQuery(query, { id });
-        return result.delete_workflows_by_pk !== null;
+        const result = await this.executeQuery(query, {
+            where,
+            limit,
+            offset,
+            order_by: orderBy
+        });
+        return result.workflow_runs.map(run => workflowRunSchema.parse(run));
     }
 }
 exports.WorkflowManager = WorkflowManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@props-labs/mesh-os",
-  "version": "0.1.23",
+  "version": "0.2.0",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
     "build": "tsc",
     "start": "ts-node src/main.ts",
     "lint": "eslint . --ext .ts",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "node --max_old_space_size=4096 node_modules/vitest/vitest.mjs",
+    "test:watch": "node --max_old_space_size=4096 node_modules/vitest/vitest.mjs --watch"
   }
 }

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

@@ -0,0 +1,6 @@
+actions: []
+custom_types:
+  enums: []
+  input_objects: []
+  objects: []
+  scalars: [] 

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

@@ -0,0 +1 @@
+[] 

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

@@ -12,4 +12,4 @@
         retries: 1
       use_prepared_statements: true
   tables: "!include default/tables/tables.yaml"
-  functions: [] 
+  functions: "!include default/functions/functions.yaml" 

package/src/templates/hasura/metadata/databases/default/functions/functions.yaml

@@ -0,0 +1,80 @@
+- function:
+    schema: public
+    name: get_connected_memories
+  configuration:
+    custom_name: getConnectedMemories
+    exposed: true
+    arguments:
+      - name: memory_id
+        type: uuid!
+      - name: relationship_type
+        type: String
+      - name: max_depth
+        type: Int
+
+- function:
+    schema: public
+    name: inspect_memory_embeddings
+  configuration:
+    custom_name: inspectMemoryEmbeddings
+    exposed: true
+    column_config:
+      memory_id:
+        custom_name: memoryId
+      embedding_norm:
+        custom_name: embeddingNorm
+      is_normalized:
+        custom_name: isNormalized
+
+- function:
+    schema: public
+    name: search_memory_chunks
+  configuration:
+    custom_name: searchMemoryChunks
+    exposed: true
+    arguments:
+      - name: query_embedding
+        type: vector!
+      - name: match_threshold
+        type: Float!
+      - name: match_count
+        type: Int!
+      - name: filter_agent_id
+        type: uuid
+      - name: memory_metadata_filter
+        type: jsonb
+      - name: chunk_metadata_filter
+        type: jsonb
+      - name: created_at_filter
+        type: jsonb
+    column_config:
+      chunk_id:
+        custom_name: chunkId
+      memory_id:
+        custom_name: memoryId
+      chunk_index:
+        custom_name: chunkIndex
+      chunk_content:
+        custom_name: chunkContent
+      chunk_metadata:
+        custom_name: chunkMetadata
+      chunk_created_at:
+        custom_name: chunkCreatedAt
+      chunk_updated_at:
+        custom_name: chunkUpdatedAt
+      memory_content:
+        custom_name: memoryContent
+      memory_type:
+        custom_name: memoryType
+      memory_status:
+        custom_name: memoryStatus
+      memory_metadata:
+        custom_name: memoryMetadata
+      memory_created_at:
+        custom_name: memoryCreatedAt
+      memory_updated_at:
+        custom_name: memoryUpdatedAt
+      agent_id:
+        custom_name: agentId
+      similarity:
+        custom_name: similarity