@trustgraph/react-state 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -313,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
     },
@@ -547,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]))));
         },
     });
@@ -567,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)
@@ -615,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
@@ -625,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,
@@ -3425,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
@@ -3441,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,
                 },
             ])
@@ -3472,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,
             };
@@ -3494,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) => {
@@ -3516,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
@@ -3532,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,
@@ -3559,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 [];
             }
@@ -3595,7 +3595,7 @@ const useLLMModels = () => {
             };
             await socket.config().putConfig([
                 {
-                    type: "parameter-types",
+                    type: "parameter-type",
                     key: name,
                     value: JSON.stringify(updatedDef),
                 },
@@ -3624,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();
@@ -3640,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)
@@ -3653,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;
@@ -3708,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;
             });
@@ -3882,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,
@@ -3894,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}`;
@@ -3904,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: {},
@@ -3942,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);
                         }
@@ -4542,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;
@@ -4554,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;