@trustgraph/react-state 0.3.1 → 1.2.0

package/dist/index.cjs

@@ -6,6 +6,7 @@ var react = require('react');
 var zustand = require('zustand');
 var reactQuery = require('@tanstack/react-query');
 var uuid = require('uuid');
+var similarity = require('compute-cosine-similarity');
 
 // Create context for notification handler
 const NotificationContext = react.createContext(null);
@@ -170,6 +171,16 @@ const useConversation = zustand.create()((set) => ({
             },
         ],
     })),
+    updateLastMessage: (text) => set((state) => {
+        if (state.messages.length === 0)
+            return state;
+        const messages = [...state.messages];
+        messages[messages.length - 1] = {
+            ...messages[messages.length - 1],
+            text: text,
+        };
+        return { messages };
+    }),
     setInput: (v) => set(() => ({
         input: v,
     })),
@@ -302,8 +313,8 @@ const DEFAULT_SETTINGS = {
         mcpTools: false, // Off by default
         schemas: false, // Off by default
         tokenCost: false, // Off by default
-        flowClasses: false, // Off by default
-        flowClassEditor: false, // Off by default - experimental feature
+        flowBlueprints: false, // Off by default
+        flowBlueprintEditor: false, // Off by default - experimental feature
         structuredQuery: false, // Off by default
         llmModels: false, // Off by default
     },
@@ -536,19 +547,19 @@ const useFlows = () => {
         },
     });
     /**
-     * Query for fetching all flow classes
+     * Query for fetching all flow blueprints
      * Uses React Query for caching and background refetching
      */
-    const flowClassesQuery = reactQuery.useQuery({
-        queryKey: ["flow-classes"],
+    const flowBlueprintsQuery = reactQuery.useQuery({
+        queryKey: ["flow-blueprints"],
         enabled: isSocketReady,
         queryFn: () => {
             return socket
                 .flows()
-                .getFlowClasses()
+                .getFlowBlueprints()
                 .then((cls) => Promise.all(cls.map((id) => socket
                 .flows()
-                .getFlowClass(id)
+                .getFlowBlueprint(id)
                 .then((cls) => [id, cls]))));
         },
     });
@@ -556,10 +567,10 @@ const useFlows = () => {
      * Mutation for starting a new flow for processing workflows
      */
     const startFlowMutation = reactQuery.useMutation({
-        mutationFn: ({ id, flowClass, description, parameters, onSuccess, }) => {
+        mutationFn: ({ id, blueprintName, description, parameters, onSuccess, }) => {
             return socket
                 .flows()
-                .startFlow(id, flowClass, description, parameters)
+                .startFlow(id, blueprintName, description, parameters)
                 .then(() => {
                 // Execute success callback if provided
                 if (onSuccess)
@@ -604,7 +615,7 @@ const useFlows = () => {
     });
     // Show loading indicators for long-running operations
     useActivity(flowsQuery.isLoading, "Loading flows");
-    useActivity(flowClassesQuery.isLoading, "Loading flow classes");
+    useActivity(flowBlueprintsQuery.isLoading, "Loading flow blueprints");
     useActivity(startFlowMutation.isPending, "Starting flow");
     useActivity(stopFlowMutation.isPending, "Stopping flows");
     // Return flows state and operations for use in components
@@ -614,11 +625,11 @@ const useFlows = () => {
         isLoading: flowsQuery.isLoading,
         isError: flowsQuery.isError,
         error: flowsQuery.error,
-        // Flow data and query state
-        flowClasses: flowClassesQuery.data,
-        isFlowClassesLoading: flowClassesQuery.isLoading,
-        isFlowClassesError: flowClassesQuery.isError,
-        flowClassesError: flowClassesQuery.error,
+        // Flow blueprint data and query state
+        flowBlueprints: flowBlueprintsQuery.data,
+        isFlowBlueprintsLoading: flowBlueprintsQuery.isLoading,
+        isFlowBlueprintsError: flowBlueprintsQuery.isError,
+        flowBlueprintsError: flowBlueprintsQuery.error,
         // Flow start operations
         startFlow: startFlowMutation.mutate,
         isStarting: startFlowMutation.isPending,
@@ -1409,273 +1420,6 @@ const useGraphEmbeddings = ({ flow, vecs, limit, collection }) => {
     };
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-/**
-* FUNCTION: isArray( value )
-*	Validates if a value is an array.
-*
-* @param {*} value - value to be validated
-* @returns {Boolean} boolean indicating whether value is an array
-*/
-function isArray$3( value ) {
-	return Object.prototype.toString.call( value ) === '[object Array]';
-} // end FUNCTION isArray()
-
-// EXPORTS //
-
-var lib$4 = Array.isArray || isArray$3;
-
-/**
-*
-*	VALIDATE: function
-*
-*
-*	DESCRIPTION:
-*		- Validates if a value is a function.
-*
-*
-*	NOTES:
-*		[1]
-*
-*
-*	TODO:
-*		[1]
-*
-*
-*	LICENSE:
-*		MIT
-*
-*	Copyright (c) 2014. Athan Reines.
-*
-*
-*	AUTHOR:
-*		Athan Reines. kgryte@gmail.com. 2014.
-*
-*/
-
-/**
-* FUNCTION: isFunction( value )
-*	Validates if a value is a function.
-*
-* @param {*} value - value to be validated
-* @returns {Boolean} boolean indicating whether value is a function
-*/
-function isFunction$3( value ) {
-	return ( typeof value === 'function' );
-} // end FUNCTION isFunction()
-
-
-// EXPORTS //
-
-var lib$3 = isFunction$3;
-
-// MODULES //
-
-var isArray$2 = lib$4,
-	isFunction$2 = lib$3;
-
-
-// DOT PRODUCT //
-
-/**
-* FUNCTION: dot( x, y[, accessor] )
-*	Computes the dot product between two arrays.
-*
-* @param {Array} x - input array
-* @param {Array} y - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {Number|Null} dot product
-*/
-function dot$1( x, y, clbk ) {
-	if ( !isArray$2( x ) ) {
-		throw new TypeError( 'dot()::invalid input argument. First argument must be an array. Value: `' + x + '`.' );
-	}
-	if ( !isArray$2( y ) ) {
-		throw new TypeError( 'dot()::invalid input argument. Second argument must be an array. Value: `' + y + '`.' );
-	}
-	if ( arguments.length > 2 ) {
-		if ( !isFunction$2( clbk ) ) {
-			throw new TypeError( 'dot()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	var len = x.length,
-		sum = 0,
-		i;
-
-	if ( len !== y.length ) {
-		throw new Error( 'dot()::invalid input argument. Arrays must be of equal length.' );
-	}
-	if ( !len ) {
-		return null;
-	}
-	if ( clbk ) {
-		for ( i = 0; i < len; i++ ) {
-			sum += clbk( x[ i ], i, 0 ) * clbk( y[ i ], i, 1 );
-		}
-	} else {
-		for ( i = 0; i < len; i++ ) {
-			sum += x[ i ] * y[ i ];
-		}
-	}
-	return sum;
-} // end FUNCTION dot()
-
-
-// EXPORTS //
-
-var lib$2 = dot$1;
-
-// MODULES //
-
-var isArray$1 = lib$4,
-	isFunction$1 = lib$3;
-
-
-// L2NORM //
-
-/**
-* FUNCTION: l2norm( arr[, accessor] )
-*	Calculates the L2 norm (Euclidean norm) of an array.
-*
-* @param {Array} arr - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {Number|Null} L2 norm or null
-*/
-function l2norm$1( arr, clbk ) {
-	if ( !isArray$1( arr ) ) {
-		throw new TypeError( 'l2norm()::invalid input argument. Must provide an array.  Value: `' + arr + '`.' );
-	}
-	if ( arguments.length > 1 ) {
-		if ( !isFunction$1( clbk ) ) {
-			throw new TypeError( 'l2norm()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	var len = arr.length,
-		t = 0,
-		s = 1,
-		r,
-		val,
-		abs,
-		i;
-
-	if ( !len ) {
-		return null;
-	}
-	if ( clbk ) {
-		for ( i = 0; i < len; i++ ) {
-			val = clbk( arr[ i ], i );
-			abs = ( val < 0 ) ? -val : val;
-			if ( abs > 0 ) {
-				if ( abs > t ) {
-					r = t / val;
-					s = 1 + s*r*r;
-					t = abs;
-				} else {
-					r = val / t;
-					s = s + r*r;
-				}
-			}
-		}
-	} else {
-		for ( i = 0; i < len; i++ ) {
-			val = arr[ i ];
-			abs = ( val < 0 ) ? -val : val;
-			if ( abs > 0 ) {
-				if ( abs > t ) {
-					r = t / val;
-					s = 1 + s*r*r;
-					t = abs;
-				} else {
-					r = val / t;
-					s = s + r*r;
-				}
-			}
-		}
-	}
-	return t * Math.sqrt( s );
-} // end FUNCTION l2norm()
-
-
-// EXPORTS //
-
-var lib$1 = l2norm$1;
-
-// MODULES //
-
-var dot = lib$2,
-	l2norm = lib$1,
-	isArray = lib$4,
-	isFunction = lib$3;
-
-
-// FUNCTIONS //
-
-/**
-* Partially applied function from the right.
-*
-* @private
-* @param {Function} fn - input function
-* @param {number} j - array index
-* @returns {Function} partially applied function
-*/
-function partial( fn, j ) {
-	return function accessor( d, i ) {
-		return fn( d, i, j );
-	};
-}
-
-
-// MAIN //
-
-/**
-* Computes the cosine similarity between two arrays.
-*
-* @param {number[]|Array} x - input array
-* @param {number[]|Array} y - input array
-* @param {Function} [accessor] - accessor function for accessing array values
-* @returns {number|null} cosine similarity or null
-*/
-function similarity( x, y, clbk ) {
-	var a, b, c;
-	if ( !isArray( x ) ) {
-		throw new TypeError( 'cosine-similarity()::invalid input argument. First argument must be an array. Value: `' + x + '`.' );
-	}
-	if ( !isArray( y ) ) {
-		throw new TypeError( 'cosine-similarity()::invalid input argument. Second argument must be an array. Value: `' + y + '`.' );
-	}
-	if ( arguments.length > 2 ) {
-		if ( !isFunction( clbk ) ) {
-			throw new TypeError( 'cosine-similarity()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' );
-		}
-	}
-	if ( x.length !== y.length ) {
-		throw new Error( 'cosine-similarity()::invalid input argument. Input arrays must have the same length.' );
-	}
-	if ( !x.length ) {
-		return null;
-	}
-	if ( clbk ) {
-		a = dot( x, y, clbk );
-		b = l2norm( x, partial( clbk, 0 ) );
-		c = l2norm( y, partial( clbk, 1 ) );
-	} else {
-		a = dot( x, y );
-		b = l2norm( x );
-		c = l2norm( y );
-	}
-	return a / ( b*c );
-}
-
-
-// EXPORTS //
-
-var lib = similarity;
-
-var similarity$1 = /*@__PURE__*/getDefaultExportFromCjs(lib);
-
 // Take the embeddings, and lookup entities using graph
 // embeddings, add embedding to each entity row, just an easy
 // place to put it
@@ -1795,7 +1539,7 @@ const addRowEmbeddings = (socket, add, remove) => (entities) => {
 };
 // Rest of the procecess is not async, so not adding progress
 const computeCosineSimilarity = () => (entities) => entities.map((ent) => {
-    const sim = similarity$1(ent.target, ent.embeddings);
+    const sim = similarity(ent.target, ent.embeddings);
     return {
         uri: ent.uri,
         label: ent.label,
@@ -1965,11 +1709,27 @@ const useInference = () => {
      * Graph RAG inference with entity discovery
      */
     const graphRagMutation = reactQuery.useMutation({
-        mutationFn: async ({ input, options, collection, }) => {
-            // Execute Graph RAG request
-            const response = await socket
-                .flow(flowId)
-                .graphRag(input, options || {}, collection);
+        mutationFn: async ({ input, options, collection, callbacks, }) => {
+            // If callbacks provided, use streaming API
+            const response = callbacks
+                ? await new Promise((resolve, reject) => {
+                    let accumulated = "";
+                    const onChunk = (chunk, complete) => {
+                        accumulated += chunk;
+                        callbacks?.onChunk?.(chunk, complete);
+                        if (complete) {
+                            resolve(accumulated);
+                        }
+                    };
+                    const onError = (error) => {
+                        callbacks?.onError?.(error);
+                        reject(new Error(error));
+                    };
+                    socket
+                        .flow(flowId)
+                        .graphRagStreaming(input, onChunk, onError, options, collection);
+                })
+                : await socket.flow(flowId).graphRag(input, options || {}, collection);
             // Get embeddings for entity discovery
             const embeddings = await socket.flow(flowId).embeddings(input);
             // Query graph embeddings to find entities
@@ -1983,8 +1743,27 @@ const useInference = () => {
      * Basic LLM text completion
      */
     const textCompletionMutation = reactQuery.useMutation({
-        mutationFn: async ({ systemPrompt, input, }) => {
-            return await socket.flow(flowId).textCompletion(systemPrompt, input);
+        mutationFn: async ({ systemPrompt, input, callbacks, }) => {
+            // If callbacks provided, use streaming API
+            return callbacks
+                ? await new Promise((resolve, reject) => {
+                    let accumulated = "";
+                    const onChunk = (chunk, complete) => {
+                        accumulated += chunk;
+                        callbacks?.onChunk?.(chunk, complete);
+                        if (complete) {
+                            resolve(accumulated);
+                        }
+                    };
+                    const onError = (error) => {
+                        callbacks?.onError?.(error);
+                        reject(new Error(error));
+                    };
+                    socket
+                        .flow(flowId)
+                        .textCompletionStreaming(systemPrompt, input, onChunk, onError);
+                })
+                : await socket.flow(flowId).textCompletion(systemPrompt, input);
         },
     });
     /**
@@ -1993,15 +1772,19 @@ const useInference = () => {
     const agentMutation = reactQuery.useMutation({
         mutationFn: async ({ input, callbacks, }) => {
             return new Promise((resolve, reject) => {
-                const onThink = (thought) => {
-                    callbacks?.onThink?.(thought);
+                let fullAnswer = "";
+                const onThink = (thought, complete) => {
+                    callbacks?.onThink?.(thought, complete);
                 };
-                const onObserve = (observation) => {
-                    callbacks?.onObserve?.(observation);
+                const onObserve = (observation, complete) => {
+                    callbacks?.onObserve?.(observation, complete);
                 };
-                const onAnswer = (answer) => {
-                    callbacks?.onAnswer?.(answer);
-                    resolve(answer);
+                const onAnswer = (answer, complete) => {
+                    fullAnswer += answer;
+                    callbacks?.onAnswer?.(answer, complete);
+                    if (complete) {
+                        resolve(fullAnswer);
+                    }
                 };
                 const onError = (error) => {
                     callbacks?.onError?.(error);
@@ -2033,6 +1816,7 @@ const useChatSession = () => {
     const notify = useNotification();
     // Conversation state
     const addMessage = useConversation((state) => state.addMessage);
+    const updateLastMessage = useConversation((state) => state.updateLastMessage);
     const setInput = useConversation((state) => state.setInput);
     const chatMode = useConversation((state) => state.chatMode);
     // Progress and activity management
@@ -2052,8 +1836,10 @@ const useChatSession = () => {
         const ragActivity = "Graph RAG: " + input;
         const embActivity = "Find entities: " + input;
         addActivity(ragActivity);
+        let accumulated = "";
+        let messageAdded = false;
         try {
-            // Execute Graph RAG with entity discovery
+            // Execute Graph RAG with streaming and entity discovery
             const result = await inference.graphRag({
                 input,
                 options: {
@@ -2063,8 +1849,21 @@ const useChatSession = () => {
                     pathLength: settings.graphrag.pathLength,
                 },
                 collection: settings.collection,
+                callbacks: {
+                    onChunk: (chunk, complete) => {
+                        accumulated += chunk;
+                        if (!messageAdded) {
+                            // Add empty message on first chunk
+                            addMessage("ai", accumulated);
+                            messageAdded = true;
+                        }
+                        else {
+                            // Update existing message with accumulated text
+                            updateLastMessage(accumulated);
+                        }
+                    },
+                },
             });
-            addMessage("ai", result.response);
             removeActivity(ragActivity);
             // Start embeddings activity
             addActivity(embActivity);
@@ -2108,12 +1907,27 @@ const useChatSession = () => {
     const handleBasicLlm = async (input) => {
         const activity = "Text completion: " + input;
         addActivity(activity);
+        let accumulated = "";
+        let messageAdded = false;
         try {
             const response = await inference.textCompletion({
                 systemPrompt: "You are a helpful assistant. Provide clear and concise responses.",
                 input,
+                callbacks: {
+                    onChunk: (chunk, complete) => {
+                        accumulated += chunk;
+                        if (!messageAdded) {
+                            // Add empty message on first chunk
+                            addMessage("ai", accumulated);
+                            messageAdded = true;
+                        }
+                        else {
+                            // Update existing message with accumulated text
+                            updateLastMessage(accumulated);
+                        }
+                    },
+                },
             });
-            addMessage("ai", response);
             removeActivity(activity);
             setEntities([]);
             return response;
@@ -2129,13 +1943,54 @@ const useChatSession = () => {
     const handleAgent = async (input) => {
         const activity = "Agent: " + input;
         addActivity(activity);
+        let thinkingAccumulated = "";
+        let thinkingMessageAdded = false;
+        let observationAccumulated = "";
+        let observationMessageAdded = false;
+        let answerAccumulated = "";
+        let answerMessageAdded = false;
         try {
             const response = await inference.agent({
                 input,
                 callbacks: {
-                    onThink: (thought) => addMessage("ai", thought, "thinking"),
-                    onObserve: (observation) => addMessage("ai", observation, "observation"),
-                    onAnswer: (answer) => addMessage("ai", answer, "answer"),
+                    onThink: (thought, complete) => {
+                        thinkingAccumulated += thought;
+                        if (!thinkingMessageAdded) {
+                            addMessage("ai", thinkingAccumulated, "thinking");
+                            thinkingMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(thinkingAccumulated);
+                        }
+                        if (complete) {
+                            thinkingAccumulated = "";
+                            thinkingMessageAdded = false;
+                        }
+                    },
+                    onObserve: (observation, complete) => {
+                        observationAccumulated += observation;
+                        if (!observationMessageAdded) {
+                            addMessage("ai", observationAccumulated, "observation");
+                            observationMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(observationAccumulated);
+                        }
+                        if (complete) {
+                            observationAccumulated = "";
+                            observationMessageAdded = false;
+                        }
+                    },
+                    onAnswer: (answer, complete) => {
+                        answerAccumulated += answer;
+                        if (!answerMessageAdded) {
+                            addMessage("ai", answerAccumulated, "answer");
+                            answerMessageAdded = true;
+                        }
+                        else {
+                            updateLastMessage(answerAccumulated);
+                        }
+                    },
                 },
             });
             removeActivity(activity);
@@ -3570,7 +3425,7 @@ const useTokenCosts = () => {
      * Uses React Query for caching and background refetching
      */
     const query = reactQuery.useQuery({
-        queryKey: ["token-costs"],
+        queryKey: ["token-cost"],
         enabled: isSocketReady,
         queryFn: () => {
             return socket
@@ -3586,17 +3441,17 @@ const useTokenCosts = () => {
         },
     });
     /**
-     * Mutation for deleting a specific model's token costs
+     * Mutation for deleting a specific model's token cost
      * Removes the token cost configuration for a given model
      */
-    const deleteTokenCostsMutation = reactQuery.useMutation({
+    const deleteTokenCostMutation = reactQuery.useMutation({
         mutationFn: ({ model, onSuccess }) => {
             // Delete the token cost configuration for the specified model
             return socket
                 .config()
                 .deleteConfig([
                 {
-                    type: "token-costs",
+                    type: "token-cost",
                     key: model,
                 },
             ])
@@ -3617,20 +3472,20 @@ const useTokenCosts = () => {
         },
         onSuccess: () => {
             // Invalidate cache to trigger refetch
-            queryClient.invalidateQueries({ queryKey: ["token-costs"] });
+            queryClient.invalidateQueries({ queryKey: ["token-cost"] });
             // Show success notification
             notify.success("Successful deletion");
         },
     });
     /**
-     * Mutation for updating token costs for a specific model
+     * Mutation for updating token cost for a specific model
      * Converts per-million token prices to per-token prices and saves
      * configuration
      */
     const updateTokenCostMutation = reactQuery.useMutation({
         mutationFn: ({ model, input_price, output_price, onSuccess }) => {
             // Convert per-million token prices to per-token prices
-            const tokenCost = {
+            const tokenCosts = {
                 input_price: input_price / 1000000,
                 output_price: output_price / 1000000,
             };
@@ -3639,9 +3494,9 @@ const useTokenCosts = () => {
                 .config()
                 .putConfig([
                 {
-                    type: "token-costs",
+                    type: "token-cost",
                     key: model,
-                    value: JSON.stringify(tokenCost),
+                    value: JSON.stringify(tokenCosts),
                 },
             ])
                 .then((x) => {
@@ -3661,14 +3516,14 @@ const useTokenCosts = () => {
         },
         onSuccess: () => {
             // Invalidate cache to refresh the token costs list
-            queryClient.invalidateQueries({ queryKey: ["token-costs"] });
+            queryClient.invalidateQueries({ queryKey: ["token-cost"] });
             notify.success("Token costs updated");
         },
     });
     // Show loading indicators for long-running operations
     useActivity(query.isLoading, "Loading token costs");
-    useActivity(deleteTokenCostsMutation.isPending, "Deleting token costs");
-    useActivity(updateTokenCostMutation.isPending, "Updating token costs");
+    useActivity(deleteTokenCostMutation.isPending, "Deleting token cost");
+    useActivity(updateTokenCostMutation.isPending, "Updating token cost");
     // Return token cost state and operations for use in components
     return {
         // Token cost query state
@@ -3677,9 +3532,9 @@ const useTokenCosts = () => {
         isError: query.isError,
         error: query.error,
         // Token cost deletion operations
-        deleteTokenCosts: deleteTokenCostsMutation.mutate,
-        isDeleting: deleteTokenCostsMutation.isPending,
-        deleteError: deleteTokenCostsMutation.error,
+        deleteTokenCost: deleteTokenCostMutation.mutate,
+        isDeleting: deleteTokenCostMutation.isPending,
+        deleteError: deleteTokenCostMutation.error,
         // Token cost update operations
         updateTokenCost: updateTokenCostMutation.mutate,
         isSubmitting: updateTokenCostMutation.isPending,
@@ -3704,7 +3559,7 @@ const useLLMModels = () => {
         queryFn: async () => {
             const response = await socket
                 .config()
-                .getConfig([{ type: "parameter-types", key: "llm-model" }]);
+                .getConfig([{ type: "parameter-type", key: "llm-model" }]);
             if (!response.values || response.values.length === 0) {
                 return [];
             }
@@ -3740,7 +3595,7 @@ const useLLMModels = () => {
             };
             await socket.config().putConfig([
                 {
-                    type: "parameter-types",
+                    type: "parameter-type",
                     key: name,
                     value: JSON.stringify(updatedDef),
                 },
@@ -3769,11 +3624,11 @@ const useLLMModels = () => {
 
 // @ts-nocheck
 /**
- * Custom hook for managing flow class operations
- * Provides functionality for fetching, creating, updating, and deleting flow classes
- * @returns {Object} Flow class state and operations
+ * Custom hook for managing flow blueprint operations
+ * Provides functionality for fetching, creating, updating, and deleting flow blueprintes
+ * @returns {Object} Flow blueprint state and operations
  */
-const useFlowClasses = () => {
+const useFlowBlueprints = () => {
     // WebSocket connection for communicating with the config service
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
@@ -3785,11 +3640,11 @@ const useFlowClasses = () => {
     const isSocketReady = connectionState?.status === "authenticated" ||
         connectionState?.status === "unauthenticated";
     /**
-     * Query for fetching all flow classes
+     * Query for fetching all flow blueprintes
      * Uses React Query for caching and background refetching
      */
     const query = reactQuery.useQuery({
-        queryKey: ["flow-classes"],
+        queryKey: ["flow-blueprints"],
         enabled: isSocketReady,
         staleTime: 0, // Force fresh data
         gcTime: 0, // Don't cache (React Query v5 uses gcTime instead of cacheTime)
@@ -3798,54 +3653,54 @@ const useFlowClasses = () => {
             try {
                 const response = await socket.config().getConfigAll();
                 // Handle both array and object responses
-                const config = response.config["flow-classes"];
+                const config = response.config["flow-blueprints"];
                 if (Array.isArray(config)) {
                     // If it's already an array, check if it's an array of [key, value] pairs
                     if (config.length > 0 &&
                         Array.isArray(config[0]) &&
                         config[0].length === 2) {
-                        // It's an array of [id, flowClass] pairs - convert to objects
-                        const converted = config.map(([id, flowClassData]) => {
-                            let flowClass = flowClassData;
-                            // If the flowClass is a JSON string, parse it
-                            if (typeof flowClassData === "string") {
+                        // It's an array of [id, flowBlueprint] pairs - convert to objects
+                        const converted = config.map(([id, flowBlueprintData]) => {
+                            let flowBlueprint = flowBlueprintData;
+                            // If the flowBlueprint is a JSON string, parse it
+                            if (typeof flowBlueprintData === "string") {
                                 try {
-                                    flowClass = JSON.parse(flowClassData);
+                                    flowBlueprint = JSON.parse(flowBlueprintData);
                                 }
                                 catch (error) {
-                                    console.error(`Failed to parse flow class JSON for ${id}:`, error);
-                                    flowClass = flowClassData;
+                                    console.error(`Failed to parse flow blueprint JSON for ${id}:`, error);
+                                    flowBlueprint = flowBlueprintData;
                                 }
                             }
                             return {
                                 id,
-                                ...flowClass,
+                                ...flowBlueprint,
                             };
                         });
                         return converted;
                     }
                     else {
-                        // It's already an array of flow class objects
+                        // It's already an array of flow blueprint objects
                         return config;
                     }
                 }
                 else if (config && typeof config === "object") {
-                    // Convert object to array of flow classes
-                    const converted = Object.entries(config).map(([id, flowClassData]) => {
-                        let flowClass = flowClassData;
-                        // If the flowClass is a JSON string, parse it
-                        if (typeof flowClassData === "string") {
+                    // Convert object to array of flow blueprintes
+                    const converted = Object.entries(config).map(([id, flowBlueprintData]) => {
+                        let flowBlueprint = flowBlueprintData;
+                        // If the flowBlueprint is a JSON string, parse it
+                        if (typeof flowBlueprintData === "string") {
                             try {
-                                flowClass = JSON.parse(flowClassData);
+                                flowBlueprint = JSON.parse(flowBlueprintData);
                             }
                             catch (error) {
-                                console.error(`Failed to parse flow class JSON for ${id}:`, error);
-                                flowClass = flowClassData;
+                                console.error(`Failed to parse flow blueprint JSON for ${id}:`, error);
+                                flowBlueprint = flowBlueprintData;
                             }
                         }
                         return {
                             id,
-                            ...flowClass,
+                            ...flowBlueprint,
                         };
                     });
                     return converted;
@@ -3853,171 +3708,171 @@ const useFlowClasses = () => {
                 return [];
             }
             catch (error) {
-                console.error("Failed to fetch flow classes:", error);
-                throw new Error("Failed to fetch flow classes");
+                console.error("Failed to fetch flow blueprintes:", error);
+                throw new Error("Failed to fetch flow blueprintes");
             }
         },
     });
     // Track loading state
-    useActivity(query.isLoading, "Loading flow classes");
+    useActivity(query.isLoading, "Loading flow blueprintes");
     /**
-     * Mutation for creating a new flow class
+     * Mutation for creating a new flow blueprint
      */
     const createMutation = reactQuery.useMutation({
-        mutationFn: async ({ id, flowClass, }) => {
+        mutationFn: async ({ id, flowBlueprint, }) => {
             try {
                 await socket.config().putConfig([
                     {
-                        type: "flow-classes",
+                        type: "flow-blueprints",
                         key: id,
-                        value: JSON.stringify(flowClass),
+                        value: JSON.stringify(flowBlueprint),
                     },
                 ]);
                 return {
                     id,
-                    ...flowClass,
+                    ...flowBlueprint,
                 };
             }
             catch (error) {
-                console.error(`Failed to create flow class ${id}:`, error);
-                throw new Error(`Failed to create flow class: ${id}`);
+                console.error(`Failed to create flow blueprint ${id}:`, error);
+                throw new Error(`Failed to create flow blueprint: ${id}`);
             }
         },
-        onSuccess: (flowClass) => {
-            // Invalidate and refetch flow classes
-            queryClient.invalidateQueries({ queryKey: ["flow-classes"] });
-            notify.success(`Flow class "${flowClass.id}" created successfully`);
+        onSuccess: (flowBlueprint) => {
+            // Invalidate and refetch flow blueprintes
+            queryClient.invalidateQueries({ queryKey: ["flow-blueprints"] });
+            notify.success(`Flow blueprint "${flowBlueprint.id}" created successfully`);
         },
         onError: (error) => {
-            notify.error(`Failed to create flow class: ${error.message}`);
+            notify.error(`Failed to create flow blueprint: ${error.message}`);
         },
     });
     /**
-     * Mutation for updating an existing flow class
+     * Mutation for updating an existing flow blueprint
      */
     const updateMutation = reactQuery.useMutation({
-        mutationFn: async ({ id, flowClass, }) => {
+        mutationFn: async ({ id, flowBlueprint, }) => {
             try {
-                // Get current flow class to merge changes
+                // Get current flow blueprint to merge changes
                 const currentResponse = await socket.config().getConfig([
                     {
-                        type: "flow-classes",
+                        type: "flow-blueprints",
                         key: id,
                     },
                 ]);
-                const updatedFlowClass = {
-                    ...currentResponse.config["flow-classes"][id],
-                    ...flowClass,
+                const updatedFlowBlueprint = {
+                    ...currentResponse.config["flow-blueprints"][id],
+                    ...flowBlueprint,
                 };
                 await socket.config().putConfig([
                     {
-                        type: "flow-classes",
+                        type: "flow-blueprints",
                         key: id,
-                        value: JSON.stringify(updatedFlowClass),
+                        value: JSON.stringify(updatedFlowBlueprint),
                     },
                 ]);
                 return {
                     id,
-                    ...updatedFlowClass,
+                    ...updatedFlowBlueprint,
                 };
             }
             catch (error) {
-                console.error(`Failed to update flow class ${id}:`, error);
-                throw new Error(`Failed to update flow class: ${id}`);
+                console.error(`Failed to update flow blueprint ${id}:`, error);
+                throw new Error(`Failed to update flow blueprint: ${id}`);
             }
         },
-        onSuccess: (flowClass) => {
+        onSuccess: (flowBlueprint) => {
             // Update cache
-            queryClient.invalidateQueries({ queryKey: ["flow-classes"] });
-            notify.success(`Flow class "${flowClass.id}" updated successfully`);
+            queryClient.invalidateQueries({ queryKey: ["flow-blueprints"] });
+            notify.success(`Flow blueprint "${flowBlueprint.id}" updated successfully`);
         },
         onError: (error) => {
-            notify.error(`Failed to update flow class: ${error.message}`);
+            notify.error(`Failed to update flow blueprint: ${error.message}`);
         },
     });
     /**
-     * Mutation for deleting a flow class
+     * Mutation for deleting a flow blueprint
      */
     const deleteMutation = reactQuery.useMutation({
         mutationFn: async (id) => {
             try {
-                await socket.flows().deleteFlowClass(id);
+                await socket.flows().deleteFlowBlueprint(id);
             }
             catch (error) {
-                console.error(`Failed to delete flow class ${id}:`, error);
+                console.error(`Failed to delete flow blueprint ${id}:`, error);
                 // Re-throw the original error to preserve the API error message
                 throw error;
             }
         },
         onSuccess: (_, id) => {
             // Remove from cache
-            queryClient.invalidateQueries({ queryKey: ["flow-classes"] });
-            notify.success(`Flow class "${id}" deleted successfully`);
+            queryClient.invalidateQueries({ queryKey: ["flow-blueprints"] });
+            notify.success(`Flow blueprint "${id}" deleted successfully`);
         },
         onError: (error) => {
             // Show the actual API error message without additional prefixes
-            notify.error(error.message || "Unknown error occurred while deleting flow class");
+            notify.error(error.message || "Unknown error occurred while deleting flow blueprint");
         },
     });
     /**
-     * Mutation for duplicating a flow class
+     * Mutation for duplicating a flow blueprint
      */
     const duplicateMutation = reactQuery.useMutation({
         mutationFn: async ({ sourceId, targetId, }) => {
             try {
-                // Get source flow class
+                // Get source flow blueprint
                 const sourceResponse = await socket.config().getConfig([
                     {
-                        type: "flow-classes",
+                        type: "flow-blueprints",
                         key: sourceId,
                     },
                 ]);
-                const sourceFlowClass = sourceResponse.config["flow-classes"][sourceId];
+                const sourceFlowBlueprint = sourceResponse.config["flow-blueprints"][sourceId];
                 // Create duplicate with updated description
-                const duplicatedFlowClass = {
-                    ...sourceFlowClass,
-                    description: `${sourceFlowClass.description || sourceId} (Copy)`,
-                    tags: [...(sourceFlowClass.tags || []), "copy"],
+                const duplicatedFlowBlueprint = {
+                    ...sourceFlowBlueprint,
+                    description: `${sourceFlowBlueprint.description || sourceId} (Copy)`,
+                    tags: [...(sourceFlowBlueprint.tags || []), "copy"],
                 };
-                // Save as new flow class
+                // Save as new flow blueprint
                 await socket.config().putConfig([
                     {
-                        type: "flow-classes",
+                        type: "flow-blueprints",
                         key: targetId,
-                        value: JSON.stringify(duplicatedFlowClass),
+                        value: JSON.stringify(duplicatedFlowBlueprint),
                     },
                 ]);
                 return {
                     id: targetId,
-                    ...duplicatedFlowClass,
+                    ...duplicatedFlowBlueprint,
                 };
             }
             catch (error) {
-                console.error(`Failed to duplicate flow class ${sourceId}:`, error);
-                throw new Error(`Failed to duplicate flow class: ${sourceId}`);
+                console.error(`Failed to duplicate flow blueprint ${sourceId}:`, error);
+                throw new Error(`Failed to duplicate flow blueprint: ${sourceId}`);
             }
         },
-        onSuccess: (flowClass) => {
-            queryClient.invalidateQueries({ queryKey: ["flow-classes"] });
-            notify.success(`Flow class duplicated as "${flowClass.id}"`);
+        onSuccess: (flowBlueprint) => {
+            queryClient.invalidateQueries({ queryKey: ["flow-blueprints"] });
+            notify.success(`Flow blueprint duplicated as "${flowBlueprint.id}"`);
         },
         onError: (error) => {
-            notify.error(`Failed to duplicate flow class: ${error.message}`);
+            notify.error(`Failed to duplicate flow blueprint: ${error.message}`);
         },
     });
     // Track mutation loading states
-    useActivity(createMutation.isPending, "Creating flow class");
-    useActivity(updateMutation.isPending, "Updating flow class");
-    useActivity(deleteMutation.isPending, "Deleting flow class");
-    useActivity(duplicateMutation.isPending, "Duplicating flow class");
+    useActivity(createMutation.isPending, "Creating flow blueprint");
+    useActivity(updateMutation.isPending, "Updating flow blueprint");
+    useActivity(deleteMutation.isPending, "Deleting flow blueprint");
+    useActivity(duplicateMutation.isPending, "Duplicating flow blueprint");
     return {
         // Query state
-        flowClasses: query.data || [],
+        flowBlueprints: query.data || [],
         isLoading: query.isLoading,
         error: query.error,
         refetch: query.refetch,
         // Utilities
-        getFlowClass: (id) => {
+        getFlowBlueprint: (id) => {
             const found = query.data?.find((fc) => {
                 return fc.id === id;
             });
@@ -4027,10 +3882,10 @@ const useFlowClasses = () => {
             return query.data?.some((fc) => fc.id === id) ?? false;
         },
         // Mutations
-        createFlowClass: createMutation.mutateAsync,
-        updateFlowClass: updateMutation.mutateAsync,
-        deleteFlowClass: deleteMutation.mutateAsync,
-        duplicateFlowClass: duplicateMutation.mutateAsync,
+        createFlowBlueprint: createMutation.mutateAsync,
+        updateFlowBlueprint: updateMutation.mutateAsync,
+        deleteFlowBlueprint: deleteMutation.mutateAsync,
+        duplicateFlowBlueprint: duplicateMutation.mutateAsync,
         // Mutation states
         isCreating: createMutation.isPending,
         isUpdating: updateMutation.isPending,
@@ -4039,9 +3894,9 @@ const useFlowClasses = () => {
     };
 };
 /**
- * Generate a unique flow class ID
+ * Generate a unique flow blueprint ID
  */
-const generateFlowClassId = (baseName = "flow-class") => {
+const generateFlowBlueprintId = (baseName = "flow-class") => {
     const timestamp = Date.now();
     const random = Math.random().toString(36).substring(2, 8);
     return `${baseName}-${timestamp}-${random}`;
@@ -4049,29 +3904,29 @@ const generateFlowClassId = (baseName = "flow-class") => {
 
 // @ts-nocheck
 /**
- * Custom hook for fetching parameter definitions for a flow class
- * @param flowClassName - The name of the flow class to fetch parameters for
+ * Custom hook for fetching parameter definitions for a flow blueprint
+ * @param flowBlueprintName - The name of the flow blueprint to fetch parameters for
  * @returns Parameter definitions, mapping, and loading states
  */
-const useFlowParameters = (flowClassName) => {
+const useFlowParameters = (flowBlueprintName) => {
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
     const isSocketReady = connectionState?.status === "authenticated" ||
         connectionState?.status === "unauthenticated";
     /**
-     * Query for fetching parameter definitions for a flow class
+     * Query for fetching parameter definitions for a flow blueprint
      */
     const parametersQuery = reactQuery.useQuery({
-        queryKey: ["flow-parameters", flowClassName],
-        enabled: isSocketReady && !!flowClassName,
+        queryKey: ["flow-parameters", flowBlueprintName],
+        enabled: isSocketReady && !!flowBlueprintName,
         queryFn: async () => {
-            if (!flowClassName)
+            if (!flowBlueprintName)
                 return null;
             try {
-                // Get flow class definition first
-                const flowClass = await socket.flows().getFlowClass(flowClassName);
+                // Get flow blueprint definition first
+                const flowBlueprint = await socket.flows().getFlowBlueprint(flowBlueprintName);
                 // Extract parameter metadata with new structure
-                const parameterMetadata = flowClass.parameters || {};
+                const parameterMetadata = flowBlueprint.parameters || {};
                 if (Object.keys(parameterMetadata).length === 0) {
                     return {
                         parameterDefinitions: {},
@@ -4087,14 +3942,14 @@ const useFlowParameters = (flowClassName) => {
                 // Fetch parameter definitions from config
                 const definitionNames = Object.values(parameterMapping);
                 const configKeys = definitionNames.map((name) => ({
-                    type: "parameter-types",
+                    type: "parameter-type",
                     key: name,
                 }));
                 const configResponse = await socket.config().getConfig(configKeys);
                 const parameterDefinitions = {};
                 // Parse config response to get parameter definitions
                 configResponse.values?.forEach((item) => {
-                    if (item.type === "parameter-types") {
+                    if (item.type === "parameter-type") {
                         try {
                             parameterDefinitions[item.key] = JSON.parse(item.value);
                         }
@@ -4687,7 +4542,7 @@ exports.RDFS_LABEL = RDFS_LABEL;
 exports.SETTINGS_STORAGE_KEY = SETTINGS_STORAGE_KEY;
 exports.createDocId = createDocId;
 exports.fileToBase64 = fileToBase64;
-exports.generateFlowClassId = generateFlowClassId;
+exports.generateFlowBlueprintId = generateFlowBlueprintId;
 exports.getTriples = getTriples;
 exports.prepareMetadata = prepareMetadata;
 exports.textToBase64 = textToBase64;
@@ -4699,7 +4554,7 @@ exports.useCollections = useCollections;
 exports.useConversation = useConversation;
 exports.useEmbeddings = useEmbeddings;
 exports.useEntityDetail = useEntityDetail;
-exports.useFlowClasses = useFlowClasses;
+exports.useFlowBlueprints = useFlowBlueprints;
 exports.useFlowParameters = useFlowParameters;
 exports.useFlows = useFlows;
 exports.useGraphEmbeddings = useGraphEmbeddings;