@props-labs/mesh-os 0.1.20 → 0.1.23

package/dist/core/client.d.ts

@@ -1,5 +1,6 @@
 import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter, EntityRelationshipType } from './taxonomy';
 import { EntityManager } from './entities';
+import { WorkflowManager } from './workflows';
 /**
  * An agent in the system.
  */
@@ -76,6 +77,7 @@ export declare class MeshOS {
     private headers;
     private openai;
     entities: EntityManager;
+    workflows: WorkflowManager;
     constructor(config?: MeshOSConfig);
     private validateSlug;
     /**
@@ -117,7 +119,7 @@ export declare class MeshOS {
     /**
      * Create a link between two memories.
      */
-    linkMemories(sourceMemoryId: string, targetMemoryId: string, relationship: EdgeType, weight?: number, metadata?: Partial<EdgeMetadata>): Promise<MemoryEdge>;
+    linkMemories(sourceMemoryId: string, targetMemoryId: string, relationship: EdgeType, weight?: number): Promise<MemoryEdge>;
     /**
      * Remove links between two memories.
      */

package/dist/core/client.js

@@ -12,6 +12,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const boxen_1 = __importDefault(require("boxen"));
 const taxonomy_1 = require("./taxonomy");
 const entities_1 = require("./entities");
+const workflows_1 = require("./workflows");
 // Constants
 const SLUG_PATTERN = /^[a-zA-Z0-9_-]+$/;
 /**
@@ -61,8 +62,9 @@ class MeshOS {
             throw new Error('OpenAI API key is required');
         }
         this.openai = new openai_1.default({ apiKey: openaiApiKey });
-        // Initialize entity manager
+        // Initialize managers
         this.entities = new entities_1.EntityManager(this.url, this.headers, this.createEmbedding.bind(this));
+        this.workflows = new workflows_1.WorkflowManager(this.url, this.headers);
     }
     validateSlug(slug) {
         return SLUG_PATTERN.test(slug);
@@ -339,19 +341,9 @@ class MeshOS {
             memories.push(memory);
             // Link chunks sequentially
             if (previousChunkId) {
-                await this.linkMemories(previousChunkId, memory.id, taxonomy_1.EdgeType.FOLLOWS_UP, 1.0, {
-                    relationship: taxonomy_1.EdgeType.FOLLOWS_UP,
-                    weight: 1.0,
-                    bidirectional: false,
-                    additional: { is_chunk_link: true }
-                });
+                await this.linkMemories(previousChunkId, memory.id, taxonomy_1.EdgeType.FOLLOWS_UP, 1.0);
                 // Also add PART_OF relationship to show these are parts of the same content
-                await this.linkMemories(memory.id, previousChunkId, taxonomy_1.EdgeType.PART_OF, 1.0, {
-                    relationship: taxonomy_1.EdgeType.PART_OF,
-                    weight: 1.0,
-                    bidirectional: true,
-                    additional: { is_chunk_link: true }
-                });
+                await this.linkMemories(memory.id, previousChunkId, taxonomy_1.EdgeType.PART_OF, 1.0);
             }
             previousChunkId = memory.id;
         }
@@ -376,21 +368,19 @@ class MeshOS {
     /**
      * Create a link between two memories.
      */
-    async linkMemories(sourceMemoryId, targetMemoryId, relationship, weight = 1.0, metadata) {
+    async linkMemories(sourceMemoryId, targetMemoryId, relationship, weight = 1.0) {
         const query = `
       mutation LinkMemories(
         $sourceMemory: uuid!,
         $targetMemory: uuid!,
         $relationship: String!,
-        $weight: float8!,
-        $metadata: jsonb!
+        $weight: float8!
       ) {
         insert_memory_edges_one(object: {
           source_memory: $sourceMemory,
           target_memory: $targetMemory,
           relationship: $relationship,
-          weight: $weight,
-          metadata: $metadata
+          weight: $weight
         }) {
           id
           source_memory
@@ -398,23 +388,14 @@ class MeshOS {
           relationship
           weight
           created_at
-          metadata
         }
       }
     `;
-        const fullMetadata = {
-            relationship,
-            weight,
-            bidirectional: false,
-            additional: {},
-            ...metadata
-        };
         const result = await this.executeQuery(query, {
             sourceMemory: sourceMemoryId,
             targetMemory: targetMemoryId,
             relationship,
-            weight,
-            metadata: fullMetadata
+            weight
         });
         // Convert snake_case to camelCase
         const { source_memory, target_memory, created_at, ...rest } = result.insert_memory_edges_one;
@@ -484,12 +465,7 @@ class MeshOS {
         if (createVersionEdge) {
             // If we got multiple memories (chunks), link the first one
             const firstNewMemory = Array.isArray(newMemories) ? newMemories[0] : newMemories;
-            await this.linkMemories(oldMemory.id, firstNewMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0, {
-                relationship: taxonomy_1.EdgeType.VERSION_OF,
-                weight: 1.0,
-                bidirectional: false,
-                additional: { version_increment: 1 }
-            });
+            await this.linkMemories(oldMemory.id, firstNewMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0);
         }
         return newMemories;
     }

package/dist/core/taxonomy.d.ts

@@ -168,6 +168,18 @@ export declare const CoreAgentStatus: {
     readonly PAUSED: "paused";
 };
 export type AgentStatus = typeof CoreAgentStatus[keyof typeof CoreAgentStatus] | string;
+/**
+ * Core workflow status types.
+ * The type allows for both predefined and custom status strings.
+ */
+export declare const CoreWorkflowStatus: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+export type WorkflowStatus = typeof CoreWorkflowStatus[keyof typeof CoreWorkflowStatus] | string;
 /**
  * Version history entry.
  */
@@ -320,3 +332,35 @@ export interface TimestampFilter {
     _lte?: string;
     _eq?: string;
 }
+/**
+ * Workflow schema definition.
+ */
+export declare const workflowSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    jobId: z.ZodString;
+    type: z.ZodString;
+    status: z.ZodDefault<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    status: string;
+    metadata: Record<string, unknown>;
+    jobId: string;
+    id?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    result?: unknown;
+}, {
+    type: string;
+    jobId: string;
+    id?: string | undefined;
+    status?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    result?: unknown;
+}>;
+export type Workflow = z.infer<typeof workflowSchema>;

package/dist/core/taxonomy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.edgeMetadataSchema = exports.memoryMetadataSchema = exports.CoreAgentStatus = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.entityMemoryLinkSchema = exports.entitySchema = exports.EntityStatus = exports.EntityRelationshipType = exports.DataType = void 0;
+exports.workflowSchema = exports.edgeMetadataSchema = exports.memoryMetadataSchema = exports.CoreWorkflowStatus = exports.CoreAgentStatus = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.entityMemoryLinkSchema = exports.entitySchema = exports.EntityStatus = exports.EntityRelationshipType = exports.DataType = void 0;
 /**
  * Taxonomy and classification models for MeshOS.
  */
@@ -143,6 +143,17 @@ exports.CoreAgentStatus = {
     ERROR: 'error',
     PAUSED: 'paused'
 };
+/**
+ * Core workflow status types.
+ * The type allows for both predefined and custom status strings.
+ */
+exports.CoreWorkflowStatus = {
+    PENDING: 'pending',
+    RUNNING: 'running',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled'
+};
 /**
  * Standardized metadata structure for memories.
  */
@@ -187,3 +198,16 @@ exports.edgeMetadataSchema = zod_1.z.object({
     bidirectional: zod_1.z.boolean().default(false),
     additional: zod_1.z.record(zod_1.z.unknown()).default({}),
 });
+/**
+ * Workflow schema definition.
+ */
+exports.workflowSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid().optional(),
+    jobId: zod_1.z.string(),
+    type: zod_1.z.string(),
+    status: zod_1.z.string().default(exports.CoreWorkflowStatus.PENDING),
+    result: zod_1.z.unknown().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).default({}),
+    createdAt: zod_1.z.string().optional(),
+    updatedAt: zod_1.z.string().optional(),
+});

package/dist/core/workflows.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Workflow management functionality for MeshOS.
+ */
+import { Workflow } from './taxonomy';
+export declare class WorkflowManager {
+    private url;
+    private headers;
+    constructor(url: string, headers: Record<string, string>);
+    /**
+     * Execute a GraphQL query.
+     */
+    private executeQuery;
+    /**
+     * Get a workflow by job ID.
+     */
+    getByJobId(jobId: string): Promise<Workflow | null>;
+    /**
+     * Create a new workflow.
+     */
+    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow>;
+    /**
+     * Get a workflow by ID.
+     */
+    get(id: string): Promise<Workflow | null>;
+    /**
+     * Get workflows with optional filtering and sorting.
+     */
+    list(options?: {
+        where?: Record<string, unknown>;
+        orderBy?: Array<{
+            column: string;
+            order: 'asc' | 'desc';
+        }>;
+        limit?: number;
+        offset?: number;
+    }): Promise<Workflow[]>;
+    /**
+     * Update a workflow.
+     */
+    update(id: string, updates: Partial<Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>>): Promise<Workflow>;
+    /**
+     * Delete a workflow.
+     */
+    delete(id: string): Promise<boolean>;
+}

package/dist/core/workflows.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowManager = void 0;
+/**
+ * Workflow management functionality for MeshOS.
+ */
+const taxonomy_1 = require("./taxonomy");
+class WorkflowManager {
+    constructor(url, headers) {
+        this.url = url;
+        this.headers = headers;
+    }
+    /**
+     * Execute a GraphQL query.
+     */
+    async executeQuery(query, variables) {
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify({
+                query,
+                variables: variables || {}
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        if (result.errors) {
+            throw new Error(result.errors[0].message);
+        }
+        return result.data;
+    }
+    /**
+     * Get a workflow by job ID.
+     */
+    async getByJobId(jobId) {
+        const query = `
+      query GetWorkflowByJobId($jobId: String!) {
+        workflows(where: {job_id: {_eq: $jobId}}, limit: 1) {
+          id
+          job_id
+          type
+          status
+          result
+          metadata
+          created_at
+          updated_at
+        }
+      }
+    `;
+        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,
+        };
+    }
+    /**
+     * Create a new workflow.
+     */
+    async create(workflow) {
+        // Validate workflow data
+        const validatedData = taxonomy_1.workflowSchema.omit({ id: true, createdAt: true, updatedAt: true }).parse(workflow);
+        const query = `
+      mutation CreateWorkflow($workflow: workflows_insert_input!) {
+        insert_workflows_one(object: $workflow) {
+          id
+          job_id
+          type
+          status
+          result
+          metadata
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            workflow: {
+                job_id: validatedData.jobId,
+                type: validatedData.type,
+                status: validatedData.status,
+                result: validatedData.result,
+                metadata: validatedData.metadata
+            }
+        });
+        // 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,
+        };
+    }
+    /**
+     * Get a workflow by ID.
+     */
+    async get(id) {
+        const query = `
+      query GetWorkflow($id: uuid!) {
+        workflows_by_pk(id: $id) {
+          id
+          job_id
+          type
+          status
+          result
+          metadata
+          created_at
+          updated_at
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        if (!result.workflows_by_pk) {
+            return null;
+        }
+        // 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,
+        };
+    }
+    /**
+     * Get workflows with optional filtering and sorting.
+     */
+    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 };
+        });
+        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
+        ) {
+          id
+          job_id
+          type
+          status
+          result
+          metadata
+          created_at
+          updated_at
+        }
+      }
+    `;
+        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,
+            };
+        });
+    }
+    /**
+     * Update a workflow.
+     */
+    async update(id, updates) {
+        const query = `
+      mutation UpdateWorkflow($id: uuid!, $updates: workflows_set_input!) {
+        update_workflows_by_pk(pk_columns: {id: $id}, _set: $updates) {
+          id
+          job_id
+          type
+          status
+          result
+          metadata
+          created_at
+          updated_at
+        }
+      }
+    `;
+        // 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,
+        };
+    }
+    /**
+     * Delete a workflow.
+     */
+    async delete(id) {
+        const query = `
+      mutation DeleteWorkflow($id: uuid!) {
+        delete_workflows_by_pk(id: $id) {
+          id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, { id });
+        return result.delete_workflows_by_pk !== null;
+    }
+}
+exports.WorkflowManager = WorkflowManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@props-labs/mesh-os",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",