@props-labs/mesh-os 0.1.20 → 0.2.0

package/dist/core/workflows.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowManager = void 0;
+/**
+ * Workflow management functionality for MeshOS.
+ */
+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 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;
+    }
+    /**
+     * List available workflow schemas
+     */
+    async listSchemas() {
+        const query = `
+      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
+          type
+          status
+          input
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        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);
+    }
+    /**
+     * Update a workflow run's status
+     */
+    async updateStatus(input) {
+        const query = `
+      mutation UpdateWorkflowStatus($id: uuid!, $status: String!, $metadata: jsonb) {
+        update_workflow_runs_by_pk(
+          pk_columns: {id: $id}, 
+          _set: {
+            status: $status,
+            metadata: $metadata
+          }
+        ) {
+          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, {
+            result: {
+                workflow_id: input.workflow_id,
+                type: input.type,
+                result: input.result,
+                metadata: input.metadata || {},
+                agent_id: input.agent_id
+            }
+        });
+        return workflowResultSchema.parse(result.insert_workflow_results_one);
+    }
+    /**
+     * Get a workflow run by ID
+     */
+    async getRun(id) {
+        const query = `
+      query GetWorkflowRun($id: uuid!) {
+        workflow_runs_by_pk(id: $id) {
+          id
+          type
+          status
+          input
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        const run = result.workflow_runs_by_pk;
+        if (!run) {
+            throw new Error(`Workflow run not found with id: ${id}`);
+        }
+        return workflowRunSchema.parse(run);
+    }
+    /**
+     * Get all results for a workflow run
+     */
+    async getResults(workflowId) {
+        const query = `
+      query GetWorkflowResults($workflow_id: uuid!) {
+        workflow_results(
+          where: {workflow_id: {_eq: $workflow_id}}
+          order_by: {created_at: asc}
+        ) {
+          id
+          workflow_id
+          type
+          result
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { workflow_id: workflowId });
+        return result.workflow_results.map(r => workflowResultSchema.parse(r));
+    }
+    /**
+     * Get the final result for a workflow run
+     */
+    async getFinalResult(workflowId) {
+        const query = `
+      query GetWorkflowFinalResult($workflow_id: uuid!) {
+        workflow_results(
+          where: {
+            workflow_id: {_eq: $workflow_id},
+            type: {_eq: "final"}
+          }
+          limit: 1
+          order_by: {created_at: desc}
+        ) {
+          id
+          workflow_id
+          type
+          result
+          metadata
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { workflow_id: workflowId });
+        return result.workflow_results[0] ? workflowResultSchema.parse(result.workflow_results[0]) : null;
+    }
+    /**
+     * List workflow runs with optional filtering and sorting
+     */
+    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 = `
+      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, {
+            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.20",
+  "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